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

st-img
chrome st-img
firefox st-img
safari st-img
ie8及以上

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

[复制链接]
Dylan疾风闪电 发布时间：2016-1-7 14:26
阅读主题, 点击返回1楼
赞 收藏 22 评论60 发布时间：2016-1-7 14:26
60个回答
Dylan疾风闪电 回答时间：2016-1-7 15:06:27
  1. /**
  2.   ******************************************************************************
  3.   * @file /DEBUG.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-19
  7.   * @brief    DEBUG：
  8.   ******************************************************************************
  9.   *用途：方便差错
  10.   */
  11.   /*实例应用步骤：
  12.   //1."main.cpp"调用fmain()修改以下函数
  13.   
  14.   #define __DEBUG_Example
  15.   void assert_failed(uint8_t* file, uint32_t line)
  16.   {
  17.       // User can add his own implementation to report the file name and line number,
  18.          ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line)
  19.     #ifdef __DEBUG_Example
  20.       printf("Wrong parameters value: file %s on line %d\r\n", file, line);
  21.     #else
  22.       // Infinite loop
  23.       while (1)
  24.       {
  25.       }
  26.     #endif
  27.   }

  29.   //2.PC端USART配置
  30.    - Connect a null-modem female/female RS232 cable between the DB9 connector
  31.         CN2(USART1) and PC serial port.
  32.    
  33.   
  34.    - Hyperterminal configuration:
  35.       - Word Length = 8 Bits
  36.       - One Stop Bit
  37.       - No parity
  38.       - BaudRate = 115200 baud
  39.       - flow control: None

  41.   //3.Terminal I/O中观察
  42.   显示printf的字符串和错误信息
  43.   STM32F10x Firmware Library compiled in DEBUG mode...
  44.   ...Run-time checking enabled

  46.   Wrong parameters value: file D:\xd_ST_ARM\(中文名乱码)\STM32F10x_StdPeriph_Driver\src\stm32f10x_rcc.cpp on line 1136
  47.   */

  49. #ifndef __DEBUG_H
  50. #define __DEBUG_H
  51. /* Includes ------------------------------------------------------------------*/
  52. #include "std32periph.h"
  53. #include <stdio.h>

  55. /* Private typedef -----------------------------------------------------------*/
  56. /* Private define ------------------------------------------------------------*/
  57. #ifdef __GNUC__
  58.   /* With GCC/RAISONANCE, small printf (option LD Linker->Libraries->Small printf
  59.      set to 'Yes') calls __io_putchar() */
  60.   #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
  61. #else
  62.   #define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
  63. #endif /* __GNUC__ */
  64. /* Private macro -------------------------------------------------------------*/
  65. /* Private variables ---------------------------------------------------------*/
  66. /* Private functions ---------------------------------------------------------*/

  68. void fmain(void)
  69. {
  70.   RCC_HSEConf(9);//72M
  71.   
  72.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA, ENABLE);
  73.   
  74.   
  75.   GPIO_InitTypeDef GPIO_InitStructure;
  76.   /* Configure USART1 Tx (PA.09) as alternate function push-pull */
  77.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  78.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  79.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  80.   GPIO_Init(GPIOA, &GPIO_InitStructure);
  81.   /* Configure USART1 Rx (PA.10) as input floating */
  82.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  83.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  84.   GPIO_Init(GPIOA, &GPIO_InitStructure);
  85.   

  87. /* USART1 configuration ------------------------------------------------------*/
  88.   /* USART1 configured as follow:
  89.         - BaudRate = 115200 baud  
  90.         - Word Length = 8 Bits
  91.         - One Stop Bit
  92.         - No parity
  93.         - Hardware flow control disabled (RTS and CTS signals)
  94.         - Receive and transmit enabled
  95.   */
  96.   USART_InitTypeDef USART_InitStructure;
  97.   USART_InitStructure.USART_BaudRate = 115200;
  98.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  99.   USART_InitStructure.USART_StopBits = USART_StopBits_1;
  100.   USART_InitStructure.USART_Parity = USART_Parity_No;
  101.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  102.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  103.   USART_Init(USART1, &USART_InitStructure);
  104.   USART_Cmd(USART1, ENABLE);
  105.   
  106.   //在PC端串口助手显示
  107.   u8 buff[] = "\r\n STM32F10x Firmware Library compiled in DEBUG mode... \n\r...Run-time checking enabled  \n\r";
  108.   u8 *p = buff;
  109.   u16 SR = USART1->SR;
  110.   #define ARR_SIZE(a) (sizeof(a)/sizeof(a[0]))//返回数组元素的个数
  111.   u8 len = ARR_SIZE(buff);
  112.   for(u8 i=0; i<len; i++)
  113.   {
  114.     USART1->DR = *p++;
  115.     while ((USART1->SR & 0x0040) == 0);
  116.   }
  117.   
  118.   //在IAR软件的输出窗口显示
  119.   printf("\r\n STM32F10x Firmware Library compiled in DEBUG mode... \n\r");
  120.   printf("...Run-time checking enabled  \n\r");
  121.   
  122.   //产生错误信息：错误的SPI时钟使能
  123.   /* Simulate wrong parameter passed to library function ---------------------*/
  124.   /* To enable SPI1 clock, RCC_APB2PeriphClockCmd function must be used and
  125.      not RCC_APB1PeriphClockCmd*/
  126.   RCC_APB1PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
  127.   
  128.   /* Some member of GPIOA_InitStructure structure are not initialized */
  129.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  130.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  131.   /* GPIOA_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; */
  132.   GPIO_Init(GPIOA, &GPIO_InitStructure);
  133. }

  135. #endif
  136. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:06:46
  1. /**
  2.   ******************************************************************************
  3.   * @file /DMA_ADC_TIM1.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-14
  7.   * @brief    DMA：通过DMA将ADC采样 反映为TIM1_CH1的脉冲频率(CCR1)
  8.   use a DMA channel to transfer continuously a data from a peripheral (ADC1)
  9.   to another peripheral (TIM1) supporting DMA transfer.
  10.   ******************************************************************************
  11.   *用途：可改为ADC->DR 直接通过 USART->DR等
  12.   */
  13.   /*实例应用步骤：
  14.   //1."main.cpp"调用fmain()
  15.   
  16.   //2.Watch中观察
  17.   TIM1_CCR1
  18.   ADC1_DR
  19.   */

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

  26. /* Private typedef -----------------------------------------------------------*/
  27. /* Private define ------------------------------------------------------------*/
  28. #define ADC1_DR_Address     0x4001244C
  29. #define TIM1_CCR1_Address   0x40012C34
  30. /* Private macro -------------------------------------------------------------*/
  31. /* Private variables ---------------------------------------------------------*/
  32. /* Private functions ---------------------------------------------------------*/

  34. void fmain(void)
  35. {
  36.   RCC_HSEConf(7);//56M

  38.   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
  39.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOC |
  40.                          RCC_APB2Periph_ADC1 | RCC_APB2Periph_TIM1, ENABLE);
  41.   //复位ADC
  42.   RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1, ENABLE);
  43.   RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC1, DISABLE);


  46.   GPIO_InitTypeDef GPIO_InitStructure;
  47.   /* Configure TIM1 Channel1 output */
  48.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
  49.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  50.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  51.   GPIO_Init(GPIOA, &GPIO_InitStructure);
  52.   /* Configure ADC Channel14 as analog input */
  53.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4  ;
  54.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;
  55.   GPIO_Init(GPIOC, &GPIO_InitStructure);


  58.   /* DMA1 Channel5 configuration ----------------------------------------------*/
  59.   DMA_InitTypeDef           DMA_InitStructure;
  60.   DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)TIM1_CCR1_Address;
  61.   DMA_InitStructure.DMA_MemoryBaseAddr = (u32)ADC1_DR_Address;
  62.   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
  63.   DMA_InitStructure.DMA_BufferSize = 1;
  64.   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  65.   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Disable;
  66.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  67.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  68.   DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  69.   DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  70.   DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  71.   DMA_Init(DMA1_Channel5, &DMA_InitStructure);
  72.   /* Enable DMA1 Channel5 */
  73.   DMA_Cmd(DMA1_Channel5, ENABLE);

  75.   /* ADC1 configuration ------------------------------------------------------*/
  76.   ADC_InitTypeDef           ADC_InitStructure;
  77.   ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
  78.   ADC_InitStructure.ADC_ScanConvMode = DISABLE;
  79.   ADC_InitStructure.ADC_ContinuousConvMode = ENABLE;
  80.   ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
  81.   ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  82.   ADC_InitStructure.ADC_NbrOfChannel = 1;
  83.   ADC_Init(ADC1, &ADC_InitStructure);
  84.   ADC_RegularChannelConfig(ADC1, ADC_Channel_14, 1, ADC_SampleTime_55Cycles5);

  86.   // TIM1_channel1：PWM mode、 TIM输出比较极性低、0x7F
  87.   // F = TIMxCLK/(PSC+1)/(ARR+1)  (56/2*2)/4=14M *0x7F
  88.   TIM1->PSC = 3;
  89.   TIM1->ARR = 0xFF0;
  90.   TIM1->CR1 = 0x0000;
  91.   TIM1->CCMR1 &= 0xFF00;
  92.   TIM1->CCMR1 |= 0x0060;
  93.   TIM1->CCER &= 0xFFF0;
  94.   TIM1->CCER |= 0x0001;

  96.   TIM_Cmd(TIM1, ENABLE);
  97.   TIM_CtrlPWMOutputs(TIM1, ENABLE);

  99.   TIM_DMACmd(TIM1, TIM_DMA_Update, ENABLE);

  101.   ADC_Cmd(ADC1, ENABLE);
  102.   ADC_ResetCalibration(ADC1);
  103.   while(ADC_GetResetCalibrationStatus(ADC1));
  104.   ADC_StartCalibration(ADC1);
  105.   while(ADC_GetCalibrationStatus(ADC1));

  107.   ADC_SoftwareStartConvCmd(ADC1, ENABLE);
  108. }

  110. #endif
  111. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:12:13
  1. /**
  2.   ******************************************************************************
  3.   * @file /DMA_FlashRAM.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-15
  7.   * @brief    DMA：从ROM中拷贝数组常量到RAM中 (存在弊端，不复位的情况下可能 FAILED)
  8.   ******************************************************************************
  9.   *用途：快速读取ROM
  10.   */
  11.   /*实例应用步骤：
  12.   //1."main.cpp"调用fmain()
  13.   
  14.   //2."stm32f10x_it.cpp"拷贝
  15.   extern vu16 CurrDataCounterEnd;
  16.   void DMA1_Channel6_IRQHandler(void)
  17.   {
  18.     if(DMA_GetITStatus(DMA1_IT_TC6))
  19.     {
  20.       CurrDataCounterEnd = DMA_GetCurrDataCounter(DMA1_Channel6);
  21.       DMA_ClearITPendingBit(DMA1_IT_GL6);
  22.     }
  23.   }

  25.   //3."stm32f10x_it.h"声明
  26.   void DMA1_Channel6_IRQHandler(void);

  28.   //4.Watch中观察
  29.   SRC_Const_Buffer[]
  30.   DST_Buffer[]
  31.   */

  33. #ifndef __DMA_FLASHRAM_H
  34. #define __DMA_FLASHRAM_H
  35. /* Includes ------------------------------------------------------------------*/
  36. #include "std32periph.h"

  38. /* Private typedef -----------------------------------------------------------*/
  39. typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;
  40. /* Private define ------------------------------------------------------------*/
  41. #define BufferSize  32
  42. /* Private macro -------------------------------------------------------------*/
  43. /* Private variables ---------------------------------------------------------*/
  44. vu16 CurrDataCounterBegin = 0, CurrDataCounterEnd = 0;
  45. volatile TestStatus TransferStatus = FAILED;
  46. uc32 SRC_Const_Buffer[BufferSize]= {0x01020304,0x05060708,0x090A0B0C,0x0D0E0F10,
  47.                                     0x11121314,0x15161718,0x191A1B1C,0x1D1E1F20,
  48.                                     0x21222324,0x25262728,0x292A2B2C,0x2D2E2F30,
  49.                                     0x31323334,0x35363738,0x393A3B3C,0x3D3E3F40,
  50.                                     0x41424344,0x45464748,0x494A4B4C,0x4D4E4F50,
  51.                                     0x51525354,0x55565758,0x595A5B5C,0x5D5E5F60,
  52.                                     0x61626364,0x65666768,0x696A6B6C,0x6D6E6F70,
  53.                                     0x71727374,0x75767778,0x797A7B7C,0x7D7E7F80};
  54. u32 DST_Buffer[BufferSize];
  55. /* Private functions ---------------------------------------------------------*/

  57. TestStatus Buffercmp(uc32* pBuffer, u32* pBuffer1, u16 BufferLength)
  58. {
  59.   while(BufferLength--)
  60.   {
  61.     if(*pBuffer != *pBuffer1)
  62.     {
  63.       return FAILED;
  64.     }
  65.    
  66.     pBuffer++;
  67.     pBuffer1++;
  68.   }

  70.   return PASSED;  
  71. }

  73. void fmain(void)
  74. {
  75.   RCC_HSEConf(9);//72M

  77.   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);

  79.   NVIC_GroupSet(NVIC_PriorityGroup_0, DMA1_Channel6_IRQn, 0);

  81.   /* DMA1 channel6 configuration */
  82.   DMA_InitTypeDef  DMA_InitStructure;
  83.   DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)SRC_Const_Buffer;
  84.   DMA_InitStructure.DMA_MemoryBaseAddr = (u32)DST_Buffer;
  85.   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  86.   DMA_InitStructure.DMA_BufferSize = BufferSize;
  87.   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable;
  88.   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  89.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
  90.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
  91.   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  92.   DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  93.   DMA_InitStructure.DMA_M2M = DMA_M2M_Enable;
  94.   DMA_Init(DMA1_Channel6, &DMA_InitStructure);

  96.   /* Enable DMA1 Channel6 Transfer Complete interrupt */
  97.   DMA_ITConfig(DMA1_Channel6, DMA_IT_TC, ENABLE);

  99.   /* Get Current Data Counter value before transfer begins */
  100.   CurrDataCounterBegin = DMA_GetCurrDataCounter(DMA1_Channel6);

  102.   /* Enable DMA1 Channel6 transfer */
  103.   DMA_Cmd(DMA1_Channel6, ENABLE);

  105.   /* Wait the end of transmission */
  106.   while (CurrDataCounterEnd != 0)
  107.   {
  108.   }
  109.   
  110.   /* Check if the transmitted and received data are equal */
  111.   TransferStatus = Buffercmp(SRC_Const_Buffer, DST_Buffer, BufferSize);
  112.   /* TransferStatus = PASSED, if the transmitted and received data
  113.      are the same */
  114.   /* TransferStatus = FAILED, if the transmitted and received data
  115.      are different */
  116. }

  118. #endif
  119. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:12:29
  1. /**
  2.   ******************************************************************************
  3.   * @file /DMA_FSMC.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-15
  7.   * @brief    DMA：通过2个DMA通道，
  8.   将32位数据SRC_Const_Buffer[]从FLASH_ROM写入外设FSMC的SRAM,
  9.   然后从外设FSMC的SRAM以8位DST_Buffer[]逐个读取数据存入 (存在弊端，不复位的情况下可能 卡while)
  10.   use two DMA channels to transfer a word data buffer from Flash memory to external SRAM memory
  11.   and to recuperate the written data from external SRAM to be stored in internal SRAM.
  12.   ******************************************************************************
  13.   *用途：快速的将32位数据转换成8位数据
  14.   */
  15.   /*实例应用步骤：
  16.   //1."main.cpp"调用fmain()

  18.   //2.Watch中观察
  19.   SRC_Const_Buffer[]
  20.   DST_Buffer[]
  21.   */

  23. #ifndef __DMA_FSMC_H
  24. #define __DMA_FSMC_H
  25. /* Includes ------------------------------------------------------------------*/
  26. #include "std32periph.h"

  28. /* Private typedef -----------------------------------------------------------*/
  29. typedef enum {FAILED = 0, PASSED = !FAILED} TestStatus;
  30. /* Private define ------------------------------------------------------------*/
  31. #define BufferSize  32
  32. #define Bank1_SRAM3_ADDR    ((u32)0x68000000)
  33. /* Private macro -------------------------------------------------------------*/
  34. /* Private variables ---------------------------------------------------------*/
  35. volatile TestStatus TransferStatus;
  36. uc32 SRC_Const_Buffer[BufferSize]= {0x01020304,0x05060708,0x090A0B0C,0x0D0E0F10,
  37.                             0x11121314,0x15161718,0x191A1B1C,0x1D1E1F20,
  38.                             0x21222324,0x25262728,0x292A2B2C,0x2D2E2F30,
  39.                             0x31323334,0x35363738,0x393A3B3C,0x3D3E3F40,
  40.                             0x41424344,0x45464748,0x494A4B4C,0x4D4E4F50,
  41.                             0x51525354,0x55565758,0x595A5B5C,0x5D5E5F60,
  42.                             0x61626364,0x65666768,0x696A6B6C,0x6D6E6F70,
  43.                             0x71727374,0x75767778,0x797A7B7C,0x7D7E7F80};
  44. u8 DST_Buffer[4*BufferSize], Idx = 0;
  45. /* Private functions ---------------------------------------------------------*/

  47. void FSMC_SRAM_Init(void)
  48. {
  49.   FSMC_NORSRAMInitTypeDef  FSMC_NORSRAMInitStructure;
  50.   FSMC_NORSRAMTimingInitTypeDef  p;
  51.   GPIO_InitTypeDef GPIO_InitStructure;
  52.   
  53.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOD | RCC_APB2Periph_GPIOG | RCC_APB2Periph_GPIOE |
  54.                          RCC_APB2Periph_GPIOF, ENABLE);
  55.   
  56. /*-- GPIO Configuration ------------------------------------------------------*/
  57.   /* SRAM Data lines configuration */
  58.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_8 | GPIO_Pin_9 |
  59.                                 GPIO_Pin_10 | GPIO_Pin_14 | GPIO_Pin_15;
  60.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  61.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  62.   GPIO_Init(GPIOD, &GPIO_InitStructure);
  63.   
  64.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_8 | GPIO_Pin_9 | GPIO_Pin_10 |
  65.                                 GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13 | GPIO_Pin_14 |
  66.                                 GPIO_Pin_15;
  67.   GPIO_Init(GPIOE, &GPIO_InitStructure);
  68.   
  69.   /* SRAM Address lines configuration */
  70.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 |
  71.                                 GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_12 | GPIO_Pin_13 |
  72.                                 GPIO_Pin_14 | GPIO_Pin_15;
  73.   GPIO_Init(GPIOF, &GPIO_InitStructure);
  74.   
  75.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3 |
  76.                                 GPIO_Pin_4 | GPIO_Pin_5;
  77.   GPIO_Init(GPIOG, &GPIO_InitStructure);
  78.   
  79.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11 | GPIO_Pin_12 | GPIO_Pin_13;
  80.   GPIO_Init(GPIOD, &GPIO_InitStructure);
  81.    
  82.   /* NOE and NWE configuration */  
  83.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 |GPIO_Pin_5;
  84.   GPIO_Init(GPIOD, &GPIO_InitStructure);
  85.   
  86.   /* NE3 configuration */
  87.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  88.   GPIO_Init(GPIOG, &GPIO_InitStructure);
  89.   
  90.   /* NBL0, NBL1 configuration */
  91.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
  92.   GPIO_Init(GPIOE, &GPIO_InitStructure);
  93.   
  94. /*-- FSMC Configuration ------------------------------------------------------*/
  95.   p.FSMC_AddressSetupTime = 0;
  96.   p.FSMC_AddressHoldTime = 0;
  97.   p.FSMC_DataSetupTime = 2;
  98.   p.FSMC_BusTurnAroundDuration = 0;
  99.   p.FSMC_CLKDivision = 0;
  100.   p.FSMC_DataLatency = 0;
  101.   p.FSMC_AccessMode = FSMC_AccessMode_A;

  103.   FSMC_NORSRAMInitStructure.FSMC_Bank = FSMC_Bank1_NORSRAM3;
  104.   FSMC_NORSRAMInitStructure.FSMC_DataAddressMux = FSMC_DataAddressMux_Disable;
  105.   FSMC_NORSRAMInitStructure.FSMC_MemoryType = FSMC_MemoryType_SRAM;
  106.   FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth = FSMC_MemoryDataWidth_16b;
  107.   FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode = FSMC_BurstAccessMode_Disable;
  108.   FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity = FSMC_WaitSignalPolarity_Low;
  109.   FSMC_NORSRAMInitStructure.FSMC_WrapMode = FSMC_WrapMode_Disable;
  110.   FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive = FSMC_WaitSignalActive_BeforeWaitState;
  111.   FSMC_NORSRAMInitStructure.FSMC_WriteOperation = FSMC_WriteOperation_Enable;
  112.   FSMC_NORSRAMInitStructure.FSMC_WaitSignal = FSMC_WaitSignal_Disable;
  113.   FSMC_NORSRAMInitStructure.FSMC_ExtendedMode = FSMC_ExtendedMode_Disable;
  114.   FSMC_NORSRAMInitStructure.FSMC_WriteBurst = FSMC_WriteBurst_Disable;
  115.   FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &p;
  116.   FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct = &p;

  118.   FSMC_NORSRAMInit(&FSMC_NORSRAMInitStructure);

  120.   /* Enable FSMC Bank1_SRAM Bank */
  121.   FSMC_NORSRAMCmd(FSMC_Bank1_NORSRAM3, ENABLE);  
  122. }

  124. TestStatus Buffercmp(uc32* pBuffer, u32* pBuffer1, u16 BufferLength)
  125. {
  126.   while(BufferLength--)
  127.   {
  128.     if(*pBuffer != *pBuffer1)
  129.     {
  130.       return FAILED;
  131.     }
  132.    
  133.     pBuffer++;
  134.     pBuffer1++;
  135.   }

  137.   return PASSED;  
  138. }

  140. void fmain(void)
  141. {
  142.   RCC_HSEConf(9);//72M

  144.   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1 | RCC_AHBPeriph_DMA2 | RCC_AHBPeriph_FSMC, ENABLE);

  146.   
  147.   /* FSMC for SRAM and SRAM pins configuration */
  148.   FSMC_SRAM_Init();

  150.   DMA_InitTypeDef    DMA_InitStructure;
  151.   /* Write to FSMC -----------------------------------------------------------*/
  152.   /* DMA2 channel5 configuration */
  153.   DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)SRC_Const_Buffer;
  154.   DMA_InitStructure.DMA_MemoryBaseAddr = (u32)Bank1_SRAM3_ADDR;   
  155.   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  156.   DMA_InitStructure.DMA_BufferSize = 32;
  157.   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable;
  158.   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  159.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;
  160.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;
  161.   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  162.   DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  163.   DMA_InitStructure.DMA_M2M = DMA_M2M_Enable;
  164.   DMA_Init(DMA2_Channel5, &DMA_InitStructure);
  165.   DMA_Cmd(DMA2_Channel5, ENABLE);
  166.   while(!DMA_GetFlagStatus(DMA2_FLAG_TC5));
  167.   DMA_ClearFlag(DMA2_FLAG_TC5);

  169.   /* Read from FSMC ----------------------------------------------------------*/
  170.   /* Destination buffer initialization */
  171.   for(Idx=0; Idx<128; Idx++)
  172.     DST_Buffer[Idx]=0;
  173.   /* DMA1 channel3 configuration */
  174.   DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)Bank1_SRAM3_ADDR;  
  175.   DMA_InitStructure.DMA_MemoryBaseAddr = (u32)DST_Buffer;
  176.   DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  177.   DMA_InitStructure.DMA_BufferSize = 128;
  178.   DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Enable;
  179.   DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  180.   DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
  181.   DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
  182.   DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
  183.   DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  184.   DMA_InitStructure.DMA_M2M = DMA_M2M_Enable;
  185.   DMA_Init(DMA1_Channel3, &DMA_InitStructure);
  186.   DMA_Cmd(DMA1_Channel3, ENABLE);
  187.   while(!DMA_GetFlagStatus(DMA1_FLAG_TC3));
  188.   DMA_ClearFlag(DMA1_FLAG_TC3);

  190.   /* Check if the transmitted and received data are equal */
  191.   TransferStatus = Buffercmp(SRC_Const_Buffer, (u32*)DST_Buffer, BufferSize);
  192.   /* TransferStatus = PASSED, if the transmitted and received data
  193.      are the same */
  194.   /* TransferStatus = FAILED, if the transmitted and received data
  195.      are different */
  196. }

  198. #endif
  199. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
Dylan疾风闪电 回答时间：2016-1-7 15:12:56
  1. /**
  2.   ******************************************************************************
  3.   * @file /EXTI_Example.h
  4.   * @author    xd.wu
  5.   * @version   V1.0
  6.   * @date     2012-4-17
  7.   * @brief    EXTI：按下PB10(Key4) 翻转绿灯(PF6)上的电平
  8.   ******************************************************************************
  9.   *用途：执行外部中断，来切换某些功能
  10.   */
  11.   /*实例应用步骤：
  12.   //1."main.cpp"调用fmain()
  13.   
  14.   //2."stm32f10x_it.cpp"拷贝
  15.   #define GPIO_LED  GPIOF
  16.   void EXTI15_10_IRQHandler(void)
  17.   {
  18.       if(EXTI_GetITStatus(EXTI_Line10) != RESET)
  19.     {
  20.       GPIO_WriteBit(GPIO_LED, GPIO_Pin_6, (BitAction)((1-GPIO_ReadOutputDataBit(GPIO_LED, GPIO_Pin_6))));
  21.   
  22.       EXTI_ClearITPendingBit(EXTI_Line10);
  23.     }
  24.   }
  25.   
  26.   //3."stm32f10x_it.h"声明
  27.   void EXTI15_10_IRQHandler(void);

  29.   //4.Watch中观察
  30.   LED
  31.   */

  33. #ifndef __EXTI_EXAMPLE_H
  34. #define __EXTI_EXAMPLE_H
  35. /* Includes ------------------------------------------------------------------*/
  36. #include "std32periph.h"

  38. /* Private typedef -----------------------------------------------------------*/
  39. /* Private define ------------------------------------------------------------*/
  40.   #define GPIO_LED        GPIOF   
  41.   #define RCC_LED         RCC_APB2Periph_GPIOF
  42.   #define GPIO_EXTI       GPIOB
  43.   #define RCC_EXTI        RCC_APB2Periph_GPIOB
  44. /* Private macro -------------------------------------------------------------*/
  45. /* Private variables ---------------------------------------------------------*/
  46. /* Private functions ---------------------------------------------------------*/

  48. void fmain(void)
  49. {
  50.   RCC_HSEConf(9);//72M

  52.   RCC_APB2PeriphClockCmd(RCC_EXTI | RCC_LED | RCC_APB2Periph_AFIO, ENABLE);
  53.   
  54.   GPIO_InitTypeDef GPIO_InitStructure;
  55.   /* Configure GPIO Led pin 6 as Output push-pull */
  56.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  57.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  58.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  59.   GPIO_Init(GPIO_LED, &GPIO_InitStructure);
  60.   /* Configure Key Button GPIO Pin as input pull-up (Key Button EXTI Line) */
  61.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  62.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
  63.   GPIO_Init(GPIO_EXTI, &GPIO_InitStructure);
  64.   

  66.   //NVIC for EXTI
  67.   NVIC_GroupSet(NVIC_PriorityGroup_0, EXTI15_10_IRQn, 0);

  69.   
  70.   /* Connect Key Button EXTI Line to Key Button GPIO Pin */
  71.   GPIO_EXTILineConfig(GPIO_PortSourceGPIOB, GPIO_PinSource10);
  72.   /* Configure Key Button EXTI Line to generate an interrupt on falling edge */  
  73.   EXTI_InitTypeDef EXTI_InitStructure;
  74.   EXTI_InitStructure.EXTI_Line = EXTI_Line10;
  75.   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  76.   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
  77.   EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  78.   EXTI_Init(&EXTI_InitStructure);

  80.   /* Generate software interrupt: simulate a falling edge applied on Key Button EXTI line */
  81.   EXTI_GenerateSWInterrupt(EXTI_Line10);
  82. }

  84. #endif
  85. /******************* (C) COPYRIGHT 2008 STMicroelectronics *****END OF FILE****/
复制代码
赞 评论
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****/
复制代码
赞 评论
wolfgang 回答时间：2016-1-7 15:25:19
Dylan疾风闪电 发表于 2016-1-7 15:12

@file /EXTI_Example.h

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

所属标签

相似分享

官网相关资源

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