自定义简单的固件库

mystm32f10x.h

  1. #ifndef __MYSTM32F10X_H
  2. #define __MYSTM32F10X_H
  4. // 用来存放STM32寄存器映射的代码
  6. // 外设
  8. #define PERIPH_BASE                         ((unsigned int)0x40000000)
  9. #define APB1PERIPH_BASE                     PERIPH_BASE
  10. #define APB2PERIPH_BASE                     (PERIPH_BASE + 0x10000)
  11. #define AHBPERIPH_BASE                     (PERIPH_BASE + 0x20000)
  13. // RCC基地址
  14. #define RCC_BASE                         (AHBPERIPH_BASE + 0x1000)
  16. // GPIOB基地址
  17. #define GPIOB_BASE                         (APB2PERIPH_BASE + 0x0C00)
  19. #define RCC_APB2ENR                         *(unsigned int*)(RCC_BASE + 0x18)
  21. //#define GPIOB_CRL                         *(unsigned int*)(GPIOB_BASE + 0x00)
  22. //#define GPIOB_CRH                         *(unsigned int*)(GPIOB_BASE + 0x04)
  23. //#define GPIOB_IDR                         *(unsigned int*)(GPIOB_BASE + 0x08)
  24. //#define GPIOB_ODR                         *(unsigned int*)(GPIOB_BASE + 0x0C)
  25. //#define GPIOB_BSRR                     *(unsigned int*)(GPIOB_BASE + 0x10)
  26. //#define GPIOB_BRR                         *(unsigned int*)(GPIOB_BASE + 0x14)
  27. //#define GPIOB_LCKR                     *(unsigned int*)(GPIOB_BASE + 0x18)
  29. typedef unsigned int unit32_t;
  30. typedef unsigned short unit16_t;
  32. /* ---------将GPIO定义成结构体------------- */
  33. typedef struct
  34. {
  35.     unit32_t CRL;
  36.     unit32_t CRH;
  37.     unit32_t IDR;
  38.     unit32_t ODR;
  39.     unit32_t BSRR;
  40.     unit32_t BRR;
  41.     unit32_t LCKR;
  43. }GPIO_TypeDef;
  45. // 强制类型转换
  46. #define GPIOB        ((GPIO_TypeDef*)GPIOB_BASE)
  49. /* ---------RCC时钟结构体------------- */
  50. typedef struct
  51. {
  52.     unit32_t CR;
  53.     unit32_t CFGR;
  54.     unit32_t CIR;
  55.     unit32_t APB2RSTR;
  56.     unit32_t APB1RSTR;
  57.     unit32_t AHBENR;
  58.     unit32_t APB2ENR;
  59.     unit32_t APB1ENR;
  60.     unit32_t BDCR;
  61.     unit32_t CSR;
  63. }RCC_TypeDef;
  65. #define RCC        ((RCC_TypeDef*)RCC_BASE)
  68. #endif /*__MYSTM32F10X_H*/

mystm32f10x_gpio.h

  1. #ifndef __STM32F10x_GPIO_H
  2. #define __STM32F10x_GPIO_H
  4. #include "stm32f10x.h"
  6. // GPIO引脚宏定义
  7. #define GPIO_Pin_0                 ((uint16_t)0x0001)  /*!< Pin 0 selected */
  8. #define GPIO_Pin_1                 ((uint16_t)0x0002)  /*!< Pin 1 selected */
  9. #define GPIO_Pin_2                 ((uint16_t)0x0004)  /*!< Pin 2 selected */
  10. #define GPIO_Pin_3                 ((uint16_t)0x0008)  /*!< Pin 3 selected */
  11. #define GPIO_Pin_4                 ((uint16_t)0x0010)  /*!< Pin 4 selected */
  12. #define GPIO_Pin_5                 ((uint16_t)0x0020)  /*!< Pin 5 selected */
  13. #define GPIO_Pin_6                 ((uint16_t)0x0040)  /*!< Pin 6 selected */
  14. #define GPIO_Pin_7                 ((uint16_t)0x0080)  /*!< Pin 7 selected */
  15. #define GPIO_Pin_8                 ((uint16_t)0x0100)  /*!< Pin 8 selected */
  16. #define GPIO_Pin_9                 ((uint16_t)0x0200)  /*!< Pin 9 selected */
  17. #define GPIO_Pin_10                ((uint16_t)0x0400)  /*!< Pin 10 selected */
  18. #define GPIO_Pin_11                ((uint16_t)0x0800)  /*!< Pin 11 selected */
  19. #define GPIO_Pin_12                ((uint16_t)0x1000)  /*!< Pin 12 selected */
  20. #define GPIO_Pin_13                ((uint16_t)0x2000)  /*!< Pin 13 selected */
  21. #define GPIO_Pin_14                ((uint16_t)0x4000)  /*!< Pin 14 selected */
  22. #define GPIO_Pin_15                ((uint16_t)0x8000)  /*!< Pin 15 selected */
  23. #define GPIO_Pin_All               ((uint16_t)0xFFFF)  /*!< All pins selected */
  26. // 定义GPIO初始化结构体
  27. typedef struct
  28. {
  29.     uint16_t GPIO_Pin;            // 选择要配置的引脚
  30.     uint16_t GPIO_Speed;        // 选择GPIO引脚的速率
  31.     uint16_t GPIO_Mode;            // 选择GPIO引脚的工作模式
  33. }GPIO_InitTypeDef;
  36. /*----------GPIO输出速率枚举定义-----------*/
  37. typedef enum
  38. {
  39.     GPIO_Speed_10MHZ = 1,        
  40.     GPIO_Speed_2MHz,
  41.     GPIO_Speed_50MHz
  43. }GPIOSpeed_TypeDef;
  46. /*-----------GPIO工作模式枚举定义---------------*/
  47. typedef enum
  48. {
  49.     GPIO_Mode_AIN = 0x00,                        // 模拟输入
  50.     GPIO_Mode_IN_FLOATIN = 0x04,                // 浮空输入
  51.     GPIO_Mode_IPD = 0x28,                        // 下拉输入
  52.     GPIO_Mode_IPU = 0x48,                        // 上拉输入
  54.     GPIO_Mode_Out_OD = 0x14,                // 开漏输出
  55.     GPIO_Mode_Out_PP = 0x10,                // 推挽输出
  56.     GPIO_Mode_AF_OD = 0x1C,                    // 复用开漏输出
  57.     GPIO_Mode_AF_PP = 0x18                    // 复用推挽输出
  59. }GPIO_Mode_TypeDef;
  62. void GPIO_SetBits(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin);
  63. void GPIO_ResetBits(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin);
  64. void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct);
  66. #endif /* __STM32F10x_GPIO_H */

mystm32f10x_gpio.c

  1. #include "stm32f10x_gpio.h"
  3. // 端口复位函数
  4. void GPIO_SetBits(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
  5. {
  6.     GPIOx->BSRR |= GPIO_Pin;
  7. }
  9. // 清除
  10. void GPIO_ResetBits(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
  11. {
  12.     GPIOx->BRR |= GPIO_Pin;
  13. }
  16. // 初始化
  17. void GPIO_Init(GPIO_TypeDef* GPIOx, GPIO_InitTypeDef* GPIO_InitStruct)
  18. {
  19.   uint32_t currentmode = 0x00, currentpin = 0x00, pinpos = 0x00, pos = 0x00;
  20.   uint32_t tmpreg = 0x00, pinmask = 0x00;
  22. /*---------------------- GPIO 模式配置 --------------------------*/
  23.   // 把输入参数GPIO_Mode的低四位暂存在currentmode
  24.   currentmode = ((uint32_t)GPIO_InitStruct->GPIO_Mode) & ((uint32_t)0x0F);
  26.   // bit4是1表示输出，bit4是0则是输入 
  27.   // 判断bit4是1还是0，即首选判断是输入还是输出模式
  28.   if ((((uint32_t)GPIO_InitStruct->GPIO_Mode) & ((uint32_t)0x10)) != 0x00)
  29.   { 
  30.     // 输出模式则要设置输出速度
  31.     currentmode |= (uint32_t)GPIO_InitStruct->GPIO_Speed;
  32.   }
  33. /*-------------GPIO CRL 寄存器配置 CRL寄存器控制着低8位IO- -------*/
  34.   // 配置端口低8位，即Pin0~Pin7
  35.   if (((uint32_t)GPIO_InitStruct->GPIO_Pin & ((uint32_t)0x00FF)) != 0x00)
  36.   {
  37.     // 先备份CRL寄存器的值
  38.     tmpreg = GPIOx->CRL;
  40.     // 循环，从Pin0开始配对，找出具体的Pin
  41.     for (pinpos = 0x00; pinpos < 0x08; pinpos++)
  42.     {
  43.      // pos的值为1左移pinpos位
  44.       pos = ((uint32_t)0x01) << pinpos;
  46.       // 令pos与输入参数GPIO_PIN作位与运算，为下面的判断作准备
  47.       currentpin = (GPIO_InitStruct->GPIO_Pin) & pos;
  49.       //若currentpin=pos,则找到使用的引脚
  50.       if (currentpin == pos)
  51.       {
  52.         // pinpos的值左移两位（乘以4），因为寄存器中4个寄存器位配置一个引脚
  53.         pos = pinpos << 2;
  54.        //把控制这个引脚的4个寄存器位清零，其它寄存器位不变
  55.         pinmask = ((uint32_t)0x0F) << pos;
  56.         tmpreg &= ~pinmask;
  58.         // 向寄存器写入将要配置的引脚的模式
  59.         tmpreg |= (currentmode << pos);  
  61.         // 判断是否为下拉输入模式
  62.         if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPD)
  63.         {
  64.           // 下拉输入模式，引脚默认置0，对BRR寄存器写1可对引脚置0
  65.           GPIOx->BRR = (((uint32_t)0x01) << pinpos);
  66.         }                
  67.         else
  68.         {
  69.           // 判断是否为上拉输入模式
  70.           if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPU)
  71.           {
  72.             // 上拉输入模式，引脚默认值为1，对BSRR寄存器写1可对引脚置1
  73.             GPIOx->BSRR = (((uint32_t)0x01) << pinpos);
  74.           }
  75.         }
  76.       }
  77.     }
  78.         // 把前面处理后的暂存值写入到CRL寄存器之中
  79.     GPIOx->CRL = tmpreg;
  80.   }
  81. /*-------------GPIO CRH 寄存器配置 CRH寄存器控制着高8位IO- -----------*/
  82.   // 配置端口高8位，即Pin8~Pin15
  83.   if (GPIO_InitStruct->GPIO_Pin > 0x00FF)
  84.   {
  85.         // // 先备份CRH寄存器的值
  86.     tmpreg = GPIOx->CRH;
  88.     // 循环，从Pin8开始配对，找出具体的Pin
  89.     for (pinpos = 0x00; pinpos < 0x08; pinpos++)
  90.     {
  91.       pos = (((uint32_t)0x01) << (pinpos + 0x08));
  93.       // pos与输入参数GPIO_PIN作位与运算
  94.       currentpin = ((GPIO_InitStruct->GPIO_Pin) & pos);
  96.      //若currentpin=pos,则找到使用的引脚
  97.       if (currentpin == pos)
  98.       {
  99.         //pinpos的值左移两位（乘以4），因为寄存器中4个寄存器位配置一个引脚
  100.         pos = pinpos << 2;
  102.         //把控制这个引脚的4个寄存器位清零，其它寄存器位不变
  103.         pinmask = ((uint32_t)0x0F) << pos;
  104.         tmpreg &= ~pinmask;
  106.         // 向寄存器写入将要配置的引脚的模式
  107.         tmpreg |= (currentmode << pos);
  109.         // 判断是否为下拉输入模式
  110.         if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPD)
  111.         {
  112.           // 下拉输入模式，引脚默认置0，对BRR寄存器写1可对引脚置0
  113.           GPIOx->BRR = (((uint32_t)0x01) << (pinpos + 0x08));
  114.         }
  115.          // 判断是否为上拉输入模式
  116.         if (GPIO_InitStruct->GPIO_Mode == GPIO_Mode_IPU)
  117.         {
  118.           // 上拉输入模式，引脚默认值为1，对BSRR寄存器写1可对引脚置1
  119.           GPIOx->BSRR = (((uint32_t)0x01) << (pinpos + 0x08));
  120.         }
  121.       }
  122.     }
  123.     // 把前面处理后的暂存值写入到CRH寄存器之中
  124.     GPIOx->CRH = tmpreg;
  125.   }
  126. }

按键设置

bsp_key.h

  1. #ifndef __BSP_KEY_H
  2. #define __BSP_KEY_H
  4. #include "stm32f10x.h"
  6. // 宏定义按键1
  7. #define KEY1_GPIO_PIN                            GPIO_Pin_0
  8. #define KEY1_GPIO_PORT                            GPIOA
  9. #define KEY1_GPIO_CLK                            RCC_APB2Periph_GPIOA
  11. // 宏定义按键2
  12. #define KEY2_GPIO_PIN                            GPIO_Pin_13
  13. #define KEY2_GPIO_PORT                            GPIOC
  14. #define KEY2_GPIO_CLK                            RCC_APB2Periph_GPIOC
  16. #define KEY_ON        1
  17. #define KEY_OFF        0
  19. void KEY_GPIO_Config(void);
  20. uint8_t Key_Scan(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin);
  22. #endif // __BSP_KEY_H

bsp_key.c

  1. #include "bsp_key.h"
  3. // 按钮配置
  4. void KEY_GPIO_Config(void)
  5. {
  7.     // KEY1
  8.     GPIO_InitTypeDef  GPIO_InitStruct;
  10.     RCC_APB2PeriphClockCmd(KEY1_GPIO_CLK, ENABLE);
  12.     GPIO_InitStruct.GPIO_Pin = KEY1_GPIO_PIN;
  14.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING; // 浮空输入模式
  16.     GPIO_Init(KEY1_GPIO_PORT, &GPIO_InitStruct);
  18.     // KEY2
  19.     GPIO_InitTypeDef  GPIO_InitStruct2;
  21.     RCC_APB2PeriphClockCmd(KEY2_GPIO_CLK, ENABLE);
  23.     GPIO_InitStruct2.GPIO_Pin = KEY2_GPIO_PIN;
  25.     GPIO_InitStruct2.GPIO_Mode = GPIO_Mode_IN_FLOATING; // 浮空输入模式 /一般是上下拉输入
  27.     GPIO_Init(KEY2_GPIO_PORT, &GPIO_InitStruct2);
  29. }
  31. uint8_t Key_Scan(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)
  32. {
  33.     // 检测输出是否为高电平
  34.     if(GPIO_ReadInputDataBit(GPIOx, GPIO_Pin) == KEY_ON)
  35.     {
  36.         // 松手检测
  37.         while(GPIO_ReadInputDataBit(GPIOx, GPIO_Pin) == KEY_ON);
  38.         return KEY_ON;
  39.     }else return KEY_OFF;
  40. }

main.c

  1. /**********************
  2. 芯片：STM32F103C8T6
  4. 实现功能：使用按键1控制led0，按键2控制led1
  6. 按键1引脚：PA0
  7. 按键2引脚：PC13
  8. led0引脚：PB0
  9. led1引脚：PB1
  10. ***********************/
  13. #include "stm32f10x.h"
  14. #include "bsp_led.h"
  15. #include "bsp_key.h"
  17. #define GPIOB_ODR_Addr    (GPIOB_BASE + 0x0C)
  18. #define PBout(n)                *(unsigned int*)((GPIOB_ODR_Addr & 0xF0000000) + 0x02000000 +((GPIOB_ODR_Addr & 0x00FFFFFF) << 5) + (n<<2))
  20. #define GPIOA_IDR_Addr    (GPIOA_BASE + 0x08)
  21. #define PAin(n)                *(unsigned int*)((GPIOA_IDR_Addr & 0xF0000000) + 0x02000000 +((GPIOA_IDR_Addr & 0x00FFFFFF) << 5) + (n<<2))
  25. int main(void)
  26. {
  28.     LED_GPIO_Config(); // 配置LED
  29.     KEY_GPIO_Config(); // 配置KEY
  31.     while(1)
  32.     {
  34.         // 按键1控制LED0
  35.         if(Key_Scan(KEY1_GPIO_PORT, KEY1_GPIO_PIN) == KEY_ON)
  36.         {
  37.             LED0_TOGGLE; // LED0翻转
  38.         }
  40.         if(Key_Scan(KEY2_GPIO_PORT, KEY2_GPIO_PIN) == KEY_ON)
  41.         {
  42.             LED1_TOGGLE; // LED1翻转
  43.         }
  45.     }
  46. }

无阻塞按键函数

  1. uint16_t count = 0;  // 计数
  2. uint8_t flag = 0;   // 记住这次的状态
  3. uint8_t flag2 = 1; // 记住上次的状态
  5. void key_scan(void)
  6. {
  8.     uint8_t temp = GPIO_ReadInputDataBit(KEY1_GPIO_PORT, KEY1_GPIO_PIN); // 按键按下时为1，弹开时0
  9.     count++;
  10.     switch(flag)
  11.     {
  12.         case 0:
  13.             if(count>10 && temp == 1)
  14.             {
  15.                 LED0(ON);
  16.                 count = 0;
  17.                 flag2 = 1;
  18.             }else if(temp == 0 && flag2 == 1)
  19.             {
  20.                 flag = 1;
  21.             }
  22.             break;
  23.         case 1:
  24.             if(count>10 && temp == 1)
  25.             {
  26.                 LED0(OFF);
  27.                 count = 0;
  28.                 flag2 = 0;
  29.             }else if(temp == 0 && flag2 == 0)
  30.             {
  31.                 flag = 0;
  32.             }
  33.             break;    
  34.     }
  36. }

无阻塞弹起发送数据

  1. extern uint8_t sw1_flag;
  2. /**
  3.   * @brief  检测SW1按键
  4.   * @param   
  5.   *     
  6.   * @retval 
  7.   */
  9. void Scan_sw1(void)
  10. {
  11.     #define KEY_WAIT_INPUT            0
  12.     #define KEY_CONFIRM_INPUT        1
  13.     #define KEY_RE_CONFIRM_INPUT    2
  14.     #define KEY_RELEASE                3
  15.     static uint16_t key_time=0;
  16.     static uint8_t key_state=0;
  17.     static uint8_t signal=0;
  18.     uint8_t key_data; 
  19.     GPIO_SetBits(GPIOA, GPIO_Pin_0);
  20.     key_data = GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0);
  21.     switch(key_state)
  22.     {
  23.         case KEY_WAIT_INPUT://wait key input
  24.             if(key_data == 0)
  25.                 key_state = KEY_CONFIRM_INPUT;
  26.             break;
  27.         case KEY_CONFIRM_INPUT://confirm key input
  28.             if(key_data == 0)
  29.             {
  30.                 key_state = KEY_RE_CONFIRM_INPUT;
  31.             }
  32.             else
  33.             {
  34.                 key_state = KEY_WAIT_INPUT;
  35.             }
  36.             break;
  37.         case KEY_RE_CONFIRM_INPUT://re-confirm key_input
  38.             {    
  39.                 static uint8_t cnt=0;
  40.                 if(key_data == 0)
  41.                 {
  42.                     if(key_time++ > 20)
  43.                     {
  44.                         key_time = 0;
  45.                         cnt = 0;
  46.                         signal=1;
  47.                         //按键标志
  48.                         //key_state = KEY_RE_CONFIRM_INPUT;
  49.                     }
  50.                 }
  51.                 else
  52.                 {
  53.                     if(signal)
  54.                     {
  55.                         if(cnt++ > 5)
  56.                         {
  57.                             cnt=0;
  58.                             signal=0;
  59.                             sw1_flag = 1;
  60.                             key_state = KEY_WAIT_INPUT;
  61.                         }                        
  62.                     }    
  63.                 }
  64.             }
  65.             break;
  66.         default:
  67.             break;
  69.     }
  70. }

main.c

  1. uint8_t sw1_flag;
  2. extern void Scan_sw1(void);
  3. extern uint8_t Scan_key_flag;
  5. TIM3_Int_Init(73,1000); // 延时毫秒
  7. while(1)
  8. {
  9.     if(Scan_key_flag) // 1ms中断
  10.     {
  11.         Scan_key_flag=0;
  12.         Scan_sw1();
  13.     }
  14.     if(sw1_flag)
  15.     {
  16.         sw1_flag=0; 
  17.         USART1_DMASendString("key_status1\n",sizeof("key_status1"));
  19.     }
  20. }

自定设置系统时钟

bsp_rccclkconfig.h文件

  1. #ifndef __BSP_RCCCLKCONFIG_H
  2. #define __BSP_RCCCLKCONFIG_H
  4. #include "stm32f10x.h"
  7. void HSE_SetSysClk(uint32_t RCC_PLLMul_x);
  8. void HSI_SetSysClk(uint32_t RCC_PLLMul_x);
  10. void MCO_GPIO_Config(void);
  12. #endif //__BSP_RCCCLKCONFIG_H

bsp_rccclkconfig.c文件

  1. #include "bsp_rccclkconfig.h"
  4. // RCC_PLLMul_x where x:[2,16]
  5. // 自定HSE系统时钟
  6. void HSE_SetSysClk(uint32_t RCC_PLLMul_x)
  7. {
  9.     // 错误状态标志
  10.     ErrorStatus HSEStatus;
  12.     RCC_DeInit(); // 将RCC寄存器复位成默认状态
  15.     // 使能HSE
  16.     RCC_HSEConfig(RCC_HSE_ON);
  18.     // 等待HSE使能成功，成功返回1，错误返回0
  19.     HSEStatus = RCC_WaitForHSEStartUp();
  21.     if(HSEStatus == SUCCESS)
  22.     {
  23.         // 启动成功
  24.         // 使能预取指
  25.         FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
  27.         // 设置flase等待周期 设置两个周期等待
  28.         FLASH_SetLatency(FLASH_Latency_2);
  30.         // 配置三个总线的分屏因子
  31.         RCC_HCLKConfig(RCC_SYSCLK_Div1); //HCLK
  32.         RCC_PCLK1Config(RCC_SYSCLK_Div2); // PCLK2
  33.         RCC_PCLK2Config(RCC_SYSCLK_Div1); // PCLK1
  35.         // 配置锁相环
  36.         RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_x); // 配置PLLCLK = HSE * RCC_PLLMul_x
  37.         RCC_PLLCmd(ENABLE); // 使能
  39.         // 等待PLL稳定
  40.         while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET){};
  42.         // 选择PLLCLK作为系统时钟
  43.         RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
  45.         // 等待PLLCLK切换成系统时钟
  46.         while(RCC_GetSYSCLKSource() != 0x08){};
  48.     }else
  49.     {
  50.         // 如果HSE启动失败，用户可以在这里添加处理错误的代码
  51.     }
  52. }
  54. // 自定HSI系统时钟
  55. void HSI_SetSysClk(uint32_t RCC_PLLMul_x)
  56. {
  58.     // 错误状态标志
  59.     __IO uint32_t HSIStatus;
  61.     RCC_DeInit(); // 将RCC寄存器复位成默认状态
  64.     // 使能HSE
  65.     RCC_HSICmd(ENABLE);
  67.     // 等待HSI使能成功，成功返回1，错误返回0
  68.     HSIStatus = RCC->CR & RCC_CR_HSIRDY;
  70.     if(HSIStatus == SUCCESS)
  71.     {
  72.         // 启动成功
  73.         // 使能预取指
  74.         FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
  76.         // 设置flase等待周期 设置两个周期等待
  77.         FLASH_SetLatency(FLASH_Latency_2);
  79.         // 配置三个总线的分屏因子 HCLK = PCLK2 PCLK1/2 = 72M
  80.         RCC_HCLKConfig(RCC_SYSCLK_Div1); // HCLK 72M
  81.         RCC_PCLK1Config(RCC_SYSCLK_Div2); // PCLK1 低速36M
  82.         RCC_PCLK2Config(RCC_SYSCLK_Div1); // PCLK2 高速72M
  84.         // 配置锁相环
  85.         RCC_PLLConfig(RCC_PLLSource_HSI_Div2, RCC_PLLMul_x); // 配置PLLCLK = HSI * RCC_PLLMul_x
  86.         RCC_PLLCmd(ENABLE); // 使能
  88.         // 等待PLL稳定
  89.         while(RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET){};
  91.         // 选择PLLCLK作为系统时钟
  92.         RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);
  94.         // 等待PLLCLK切换成系统时钟
  95.         while(RCC_GetSYSCLKSource() != 0x08){};
  97.     }else
  98.     {
  99.         // 如果HSI启动失败，用户可以在这里添加处理错误的代码
  100.     }
  101. }
  103. // 初始化MCO的GPIO 用于向外输出频率
  104. void MCO_GPIO_Config(void)
  105. {
  106.     GPIO_InitTypeDef GPIO_InitStruct;
  108.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
  110.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
  111.     GPIO_InitStruct.GPIO_Pin = GPIO_Pin_8;
  112.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  114.     GPIO_Init(GPIOA, &GPIO_InitStruct);
  115. }

man.c文件

  1. int main(void)
  2. {
  3.     HSE_SetSysClk(RCC_PLLMul_9); // 自定设置系统时钟
  5.     // 配置MCO 用于向外输出频率
  6.     MCO_GPIO_Config(); // 初始化引脚
  7.     RCC_MCOConfig(RCC_MCO_SYSCLK); // 使能
  8. }

野火教程链接https://www.bilibili.com/video/BV1yW411Y7Gw?p=25
F103ZET6核心板.zip

GPIO外部中断设置-EXTI中断-对按钮操作

使用EXTI来实现按键控制led亮-灭

bsp_exti.h

  1. #ifndef __BSP_EXTI_H
  2. #define __BSP_EXTI_H
  4. #include "stm32f10x.h"
  7. #define KEY1_INT_GPIO_PIN                                    GPIO_Pin_0
  8. #define KEY1_INT_GPIO_PORT                                    GPIOA
  9. #define KEY1_INT_GPIO_CLK                                    RCC_APB2Periph_GPIOA
  11. void EXTI_NVIC_Config(void);
  12. void EXIT_Key_Config(void);
  15. #endif // __BSP_EXTI_H

bsp_exti.c

  1. #include "bsp_exti.h"
  3. // 配置中断优先级 static表示静态作用域，只能被bsp_exti文件内调用
  4. static void EXTI_NVIC_Config(void)
  5. {
  6.     /* 初始化NVIC,用于处理中断 */
  8.     // NVIC配置的变量值设置
  9.     NVIC_InitTypeDef NVIC_InitStrct;
  11.     // 中断分组设置
  12.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1); // 组1
  14.     NVIC_InitStrct.NVIC_IRQChannel = EXTI0_IRQn; // 配置中断源
  15.     NVIC_InitStrct.NVIC_IRQChannelPreemptionPriority = 1; // 抢占优先级
  16.     NVIC_InitStrct.NVIC_IRQChannelSubPriority = 1; // 响应优先级
  17.     NVIC_InitStrct.NVIC_IRQChannelCmd = ENABLE;
  18.     NVIC_Init(&NVIC_InitStrct); // 进行初始化
  20. }
  22. // 外部中断 GPIO的外部中断由EXTI控制
  23. void EXIT_Key_Config(void)
  24. {
  26.     GPIO_InitTypeDef GPIO_InitStruct; // GPIO变量设置
  27.     EXTI_InitTypeDef EXTI_InitStruct; // EXTI变量设置
  29.     // 配置中断优先级
  30.     EXTI_NVIC_Config();
  32.     // 初始化要连接到EXTI的GPIO
  33.     RCC_APB2PeriphClockCmd(KEY1_INT_GPIO_CLK, ENABLE); // 打开GPIO对应的时钟
  34.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN_FLOATING; // 浮空输入
  35.     GPIO_InitStruct.GPIO_Pin = KEY1_INT_GPIO_PIN;
  36.     GPIO_Init(KEY1_INT_GPIO_PORT, &GPIO_InitStruct);
  38.     // 初始化EXTI 用于产生中断/事件
  39.     RCC_APB2PeriphResetCmd(RCC_APB2Periph_AFIO, ENABLE); // 打开EXTI对应的时钟
  40.     GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource0); // 输入线
  42.     EXTI_InitStruct.EXTI_Line = EXTI_Line0; // 线为0
  43.     EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt; // 模式配置成中断模式
  44.     EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising; // 上升沿触发
  45.     EXTI_InitStruct.EXTI_LineCmd = ENABLE; // 使能中断屏蔽寄存器设为1
  46.     EXTI_Init(&EXTI_InitStruct); // 将设置的值进行配置
  50.     // 编写中断服务函数
  51.     // 中断函数都在stm32f10x_it 该中断为 EXTI0_IRQHandler
  52. }

stm32f10x_it.c

  1. #include "bsp_led.h"
  2. #include "bsp_exti.h"
  4. // EXTI0中断函数
  5. void EXTI0_IRQHandler(void)
  6. {
  7.     // 判断中断标志位是否为1
  8.     if(EXTI_GetITStatus(EXTI_Line0) != RESET)
  9.     {
  10.         LED0_TOGGLE;
  11.     }
  13.     // 清除中断标志位
  14.     EXTI_ClearITPendingBit(EXTI_Line0);
  15. }

main.c

  1. /**********************
  2. 芯片：STM32F103C8T6
  4. 实现功能：使用EXTI来实现按键控制led亮-灭
  6. KEY引脚：PA0
  7. LED引脚：PC0
  8. ***********************/
  11. #include "stm32f10x.h"
  12. #include "bsp_led.h"
  13. #include "bsp_key.h"
  14. #include "bsp_rccclkconfig.h"
  15. #include "bsp_exti.h"
  17. #define GPIOB_ODR_Addr    (GPIOB_BASE + 0x0C)
  18. #define PBout(n)                *(unsigned int*)((GPIOB_ODR_Addr & 0xF0000000) + 0x02000000 +((GPIOB_ODR_Addr & 0x00FFFFFF) << 5) + (n<<2))
  20. #define GPIOA_IDR_Addr    (GPIOA_BASE + 0x08)
  21. #define PAin(n)                *(unsigned int*)((GPIOA_IDR_Addr & 0xF0000000) + 0x02000000 +((GPIOA_IDR_Addr & 0x00FFFFFF) << 5) + (n<<2))
  25. int main(void)
  26. {
  28.     EXIT_Key_Config(); // 初始化
  30.     LED_GPIO_Config(); // 配置LED
  32.     while(1)
  33.     {
  35.     }
  36. }

野火视频教程：https://www.bilibili.com/video/BV1yW411Y7Gw?p=29

SysTick系统滴答定时器

SysTick寄存器介绍

image.png
image.png

SysTick 初始化函数

  1. /**
  2.  * @brief 启动系统滴答定时器 SysTick
  3.  * @param 无
  4.  * @retval 无
  5.  */
  6. void SysTick_Init(void)
  7. {
  8.     /* SystemFrequency / 1000 1ms 中断一次
  9.      * SystemFrequency / 100000 10us 中断一次
  10.      * SystemFrequency / 1000000 1us 中断一次
  11.      */
  12.     if (SysTick_Config(SystemCoreClock / 100000)) {
  13.         /* Capture error */
  14.         while (1);
  15.     }
  16. }

SysTick 初始化函数由用户编写，里面调用了 SysTick_Config() 这个固件库函数，通过设置该固件库函数的形参，就决定了系统定时器经过多少时间就产生一次中断。

SysTick中断时间计算

SysTick 定时器的计数器是向下递减计数的，计数一次的时间 TDEC=1/CLKAHB，当重装载寄存器中的值VALUELOAD 减到0的时候，产生中断 ， 可知中断一次的时间 TINT = VALUELOAD * TDEC = VALUELOAD/CLKAHB ，其中 CLKAHB = 72MHZ 。 如果设置VALUELOAD为72，那中断一次的时间 TINT = 72/72M = 1us。不过 1us 的中断没啥意义，整个程序的重心都花在进出中断上了，根本没有时间处理其他的任务。 

  1. SysTick_Config(SystemCoreClock / 100000))

SysTick_Config() 的形我们配置为 SystemCoreClock / 100000 = 72M/100000 = 720，从刚刚分析我们知道这个形参的值最终是写到重装载寄存器 LOAD 中的，从而可知我们现在把 SysTick 定时器中断一次的时间TINT = 720/72M = 10us。

SysTick定时器时间计算

t：一个计数循环的时间，跟reload和CLK有关
CLK：72M或者9M，有CTRL寄存器配置
RELOAD：24位，用户自己配置
t = reload (1/clk)
如：
clk = 72M时，t = 72(1/72M) = 1us
clk = 72M时，t = 72000*(1/72M) = 1ms
时间单位换算
1s = 1000ms = 1000 000us = 1000 000 000ns

SysTick配置库函数

在固件库文件：core_cm3.h中定义
image.png

SysTick中断优先级

1.STM32里面无论是内核还是外设都是使用4个二进制位来表示中断优先级。
2.中断优先级的分组对内核与外设同样适用。当比较的时候，只需要把内核外设的中断优先级的四个为按照外设的中断优先级来分组来解析即可，即认为的分出抢占优先级和子优先级。

对应的野火教程：https://www.bilibili.com/video/BV1yW411Y7Gw?p=30

使用SysTick中断来实现定时器

bsp_systick.h

  1. #ifndef __BSP_SYSTICK_H
  2. #define __BSP_SYSTICK_H
  4. #include "stm32f10x.h"
  5. #include "core_cm3.h"
  7. void SysTick_Delay_us(uint32_t us);
  8. void SysTick_Delay_ms(uint32_t ms);
  10. #endif // __BSP_SYSTICK_H

bsp_systick.c

  1. #include "bsp_systick.h"
  4. // 定时1us
  5. void SysTick_Delay_us(uint32_t us)
  6. {
  7.     // 初始化
  8.     SysTick_Config(72); // 配置1us的时间
  10.     for(uint16_t i=0; i<us; i++)
  11.     {
  12.         // 当计数器减到0时，则控制及状态寄存器的第16位为1即COUNTFLAG=1
  13.         while(!((SysTick->CTRL) & (1<<16)));
  14.     }
  16.     // 关闭定时器
  17.     SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
  18. }
  21. // 定时1ms
  22. void SysTick_Delay_ms(uint32_t ms)
  23. {
  24.     // 初始化
  25.     SysTick_Config(72000); // 配置1ms的时间
  27.     for(uint16_t i=0; i<ms; i++)
  28.     {
  29.         // 
  30.         while(!((SysTick->CTRL) & (1<<16)));
  31.     }
  33.     // 关闭定时器
  34.     SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
  35. }

main.c

  1. /**********************
  2. 芯片：STM32F103C8T6
  4. 实现功能：使用Systick中断来实现led的亮灭
  6. LED引脚：PC0
  7. ***********************/
  10. #include "stm32f10x.h"
  11. #include "bsp_led.h"
  12. #include "bsp_systick.h"
  14. int main(void)
  15. {    
  16.     LED_GPIO_Config(); // 配置LED
  18.     while(1)
  19.     {
  20.         LED0(OFF);
  21.         SysTick_Delay_ms(1000); // 延时1s
  22.         LED0(ON);
  23.         SysTick_Delay_ms(1000); // 延时1s
  24.     }
  25. }

USART-串口通信

串口通信协议

1.RS232标准

RS-232 标准的串口设备间常见的通讯结构图如下
image.png
在上面的通讯方式中，两个通讯设备的“DB9 接口”之间通过串口信号线建立起连接，串口信号线中使用“RS-232标准”传输数据信号。由于 RS-232 电平标准的信号不能直接被控制器直接识别，所以这些信号会经过一个“电平转换芯片”转换成控制器能识别的“TTL 标准”的电平信号，才能实现通讯。

2. 电平标准

根据通讯使用的电平标准不同，串口通讯可分为 TTL 标准及 RS-232 标准

通讯标准 电平标准(发送端)
5V TTL 逻辑 1： 2.4V-5V逻辑 0： 0~0.5V
RS-232 逻辑 1： -15V~-3V逻辑 0： +3V~+15V 
  1.  常见的电子电路中常使用 TTL 的电平标准，理想状态下，使用 5V 表示二进制逻辑 1，使用 0V 表示逻辑 0；而为了增加串口通讯的远距离传输及抗干扰能力，它使用-15V 表示逻辑1， +15V 表示逻辑 0。使用 RS232 与 TTL 电平校准表示同一个信号时的对比 <br />![image.png](https://cdn.nlark.com/yuque/0/2020/png/198326/1593697143048-78f22b7b-885d-4e7a-9e81-8f2da54f046d.png#align=left&display=inline&height=330&margin=%5Bobject%20Object%5D&name=image.png&originHeight=623&originWidth=1039&size=203869&status=done&style=none&width=551)<br />因为控制器一般使用 TTL 电平标准，所以常常会使用 MA3232 芯片对 TTL 及 RS-232电平的信号进行互相转换。

使用固件库操作USART

USART初始化结构体

  1. typedef struct
  2. {
  3.     uint32_t USART_BaudRate;    //波特率 BRR
  4.     uint16_t USART_WordLength;  //字长 CR1_M
  5.     uint16_t USART_StopBits;    //停止位 CR2_STOP
  6.     uint16_t USART_Parity;        //校验控制 CR1_PCE、CR1_PS
  7.     uint16_t USART_Mode;        //模式选择 CR1_TE、CR1_RE
  8.     // 硬件流选择 CR3_CTSE、CR3_RTSE
  9.     uint16_t USART_HardwareFlowControl;
  10. }USART_InitTypeDef;

同步时钟初始化结构体

  1. typedef struct
  2. {
  3.     uint16_t USART_Clock;              // 同步时钟 CR2_CLKEN
  4.     uint16_t USART_CPOL;          // 极性 CR2_CPOL
  5.     uint16_t USART_CPHA;          // 相位 CR2_CPHA
  6.     uint16_t USART_LastBit;      // 最后一个位的时钟脉冲 CR2_LBC
  7. }USART_ClockInitTypeDef;

向串口发送和接收数据实例

bsp_usart.h

  1. #ifndef __BSP_USART_H
  2. #define __BSP_USART_H
  4. #include "stm32f10x.h"
  5. #include <stdio.h> // c语言的库函数
  7. /*
  8. * 串口宏定义，不同的串口挂载的总线和 IO 不一样，移植时需要修改这几个宏
  9.  */
  11. // 分别给5个串口定义5个宏，使用哪个串口时就打开哪个
  12. #define DEBUG_USART1        0
  13. #define DEBUG_USART2        0
  14. #define DEBUG_USART3        0
  15. #define DEBUG_USART4        0
  16. #define DEBUG_USART5        1
  19. #if DEBUG_USART1
  20. // 串口1-USART1宏定义
  21. #define DEBUG_USARTx                        USART1
  22. #define DEBUG_USART_CLK                        RCC_APB2Periph_USART1
  23. #define DEBUG_USART_APBxClkCmd                RCC_APB2PeriphClockCmd
  24. #define DEBUG_USART_BAUDRATE                115200
  26. // USART GPIO 引脚宏定义
  27. #define DEBUG_USART_GPIO_CLK                 (RCC_APB2Periph_GPIOA)
  28. #define DEBUG_USART_GPIO_APBxClkCmd            RCC_APB2PeriphClockCmd
  30. #define DEBUG_USART_TX_GPIO_PORT             GPIOA
  31. #define DEBUG_USART_TX_GPIO_PIN             GPIO_Pin_9
  32. #define DEBUG_USART_RX_GPIO_PORT            GPIOA
  33. #define DEBUG_USART_RX_GPIO_PIN             GPIO_Pin_10
  35. #define DEBUG_USART_IRQ                     USART1_IRQn
  36. #define DEBUG_USART_IRQHandler                 USART1_IRQHandler
  38. #elif DEBUG_USART2
  39. // 串口2-USART2宏定义
  40. #define DEBUG_USARTx                        USART2
  41. #define DEBUG_USART_CLK                        RCC_APB1Periph_USART2
  42. #define DEBUG_USART_APBxClkCmd                RCC_APB1PeriphClockCmd
  43. #define DEBUG_USART_BAUDRATE                115200
  45. // USART GPIO 引脚宏定义
  46. #define DEBUG_USART_GPIO_CLK                 (RCC_APB2Periph_GPIOA)
  47. #define DEBUG_USART_GPIO_APBxClkCmd            RCC_APB2PeriphClockCmd
  49. #define DEBUG_USART_TX_GPIO_PORT             GPIOA
  50. #define DEBUG_USART_TX_GPIO_PIN             GPIO_Pin_2
  51. #define DEBUG_USART_RX_GPIO_PORT            GPIOA
  52. #define DEBUG_USART_RX_GPIO_PIN             GPIO_Pin_3
  54. #define DEBUG_USART_IRQ                     USART2_IRQn
  55. #define DEBUG_USART_IRQHandler                 USART2_IRQHandler
  59. #elif DEBUG_USART3
  60. // 串口3-USART3宏定义
  61. #define DEBUG_USARTx                        USART3
  62. #define DEBUG_USART_CLK                        RCC_APB1Periph_USART3
  63. #define DEBUG_USART_APBxClkCmd                RCC_APB1PeriphClockCmd
  64. #define DEBUG_USART_BAUDRATE                115200
  66. // USART GPIO 引脚宏定义
  67. #define DEBUG_USART_GPIO_CLK                 (RCC_APB2Periph_GPIOB)
  68. #define DEBUG_USART_GPIO_APBxClkCmd            RCC_APB2PeriphClockCmd
  70. #define DEBUG_USART_TX_GPIO_PORT             GPIOB
  71. #define DEBUG_USART_TX_GPIO_PIN             GPIO_Pin_10
  72. #define DEBUG_USART_RX_GPIO_PORT            GPIOB
  73. #define DEBUG_USART_RX_GPIO_PIN             GPIO_Pin_11
  75. #define DEBUG_USART_IRQ                     USART3_IRQn
  76. #define DEBUG_USART_IRQHandler                 USART3_IRQHandler
  79. #elif DEBUG_USART4
  80. // 串口4-USART4宏定义
  81. #define DEBUG_USARTx                        UART4
  82. #define DEBUG_USART_CLK                        RCC_APB1Periph_UART4
  83. #define DEBUG_USART_APBxClkCmd                RCC_APB1PeriphClockCmd
  84. #define DEBUG_USART_BAUDRATE                115200
  86. // USART GPIO 引脚宏定义
  87. #define DEBUG_USART_GPIO_CLK                 (RCC_APB2Periph_GPIOC)
  88. #define DEBUG_USART_GPIO_APBxClkCmd            RCC_APB2PeriphClockCmd
  90. #define DEBUG_USART_TX_GPIO_PORT             GPIOC
  91. #define DEBUG_USART_TX_GPIO_PIN             GPIO_Pin_10
  92. #define DEBUG_USART_RX_GPIO_PORT            GPIOC
  93. #define DEBUG_USART_RX_GPIO_PIN             GPIO_Pin_11
  95. #define DEBUG_USART_IRQ                     UART4_IRQn
  96. #define DEBUG_USART_IRQHandler                 UART4_IRQHandler
  99. #elif DEBUG_USART5
  100. // 串口5-USART5宏定义
  101. #define DEBUG_USARTx                        UART5
  102. #define DEBUG_USART_CLK                        RCC_APB1Periph_UART5
  103. #define DEBUG_USART_APBxClkCmd                RCC_APB1PeriphClockCmd
  104. #define DEBUG_USART_BAUDRATE                115200
  106. // USART GPIO 引脚宏定义
  107. #define DEBUG_USART_GPIO_CLK                 (RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOD)
  108. #define DEBUG_USART_GPIO_APBxClkCmd            RCC_APB2PeriphClockCmd
  110. #define DEBUG_USART_TX_GPIO_PORT             GPIOC
  111. #define DEBUG_USART_TX_GPIO_PIN             GPIO_Pin_12
  112. #define DEBUG_USART_RX_GPIO_PORT            GPIOD
  113. #define DEBUG_USART_RX_GPIO_PIN             GPIO_Pin_2
  115. #define DEBUG_USART_IRQ                     UART5_IRQn
  116. #define DEBUG_USART_IRQHandler                 UART5_IRQHandler
  118. #endif
  121. void USART_Config(void);
  122. void Usart_SendByte(USART_TypeDef* pUSARTx, uint8_t data);
  123. void Usart_SendHalfWold(USART_TypeDef* pUSARTx, uint16_t data);
  124. void Usart_SendArray(USART_TypeDef* pUSARTx, uint8_t *array, uint8_t num);
  125. void Usart_SendStr(USART_TypeDef* pUSARTx, uint8_t *str);
  127. #endif // __BSP_USART_H

bsp_usart.c

  1. #include "bsp_usart.h"
  4. // 中断控制器NVIC配置
  5. static void NVIC_Configuration(void)
  6. {
  8.   NVIC_InitTypeDef NVIC_InitStructure;
  10.   /* 嵌套向量中断控制器组选择 */
  11.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  13.   /* 配置 USART 为中断源 */
  14.   NVIC_InitStructure.NVIC_IRQChannel = DEBUG_USART_IRQ;
  16.   /* 抢断优先级为 1 */
  17.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  19.   /* 子优先级为 1 */
  20.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  22.   /* 使能中断 */
  23.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  25.   /* 初始化配置 NVIC */
  26.   NVIC_Init(&NVIC_InitStructure);
  27. }
  31. // USART初始化配置
  32. void USART_Config(void)
  33. {
  34.   GPIO_InitTypeDef        GPIO_InitStructure;
  35.   USART_InitTypeDef        USART_InitStructure;
  37.   // 打开串口GPIO的时钟
  38.   DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
  40.   // 打开串口外设的时钟
  41.   DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);
  43.   // 将 USART Tx 的 GPIO 配置为推挽复用模式
  44.   GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
  45.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  46.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  47.   GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);
  49.   // 将 USART Rx 的 GPIO 配置为浮空输入模式
  50.   GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
  51.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  52.   GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);
  54.   // 配置串口的工作参数
  55.   // 配置波特率
  56.   USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
  58.     // 配置 针数据字长
  59.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  61.     // 配置停止位
  62.   USART_InitStructure.USART_StopBits = USART_StopBits_1;
  64.   // 配置校验位
  65.   USART_InitStructure.USART_Parity = USART_Parity_No ;
  67.   // 配置硬件流控制
  68.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  70.   // 配置工作模式，收发一起
  71.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  72.   // 完成串口的初始化配置
  73.   USART_Init(DEBUG_USARTx, &USART_InitStructure);
  75.   // 串口中断优先级配置
  76.   NVIC_Configuration();
  78.   // 使能串口接收中断
  79.   USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE);
  81.   // 使能串口
  82.   USART_Cmd(DEBUG_USARTx, ENABLE);
  83. }
  85. // 给串口发送一个字节数据
  86. void Usart_SendByte(USART_TypeDef* pUSARTx, uint8_t data)
  87. {
  88.     // 发送数据
  89.     USART_SendData(pUSARTx, data);
  91.     // 检测传输数据寄存器空标志
  92.     while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
  93. }    
  95. // 给串口发送两个字节数据
  96. void Usart_SendHalfWold(USART_TypeDef* pUSARTx, uint16_t data)
  97. {
  98.     uint8_t temp_h, temp_l;
  100.     // 高8位
  101.     temp_h = (data & 0xff00) >> 8;
  103.     // 低8位
  104.     temp_l = data & 0xff;
  107.     /* 发送高8位数据 */
  108.     USART_SendData(pUSARTx, temp_h);
  110.     // 检测传输数据寄存器空标志
  111.     while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
  113.     /* 发送低8位数据 */
  114.     USART_SendData(pUSARTx, temp_l);
  116.     // 检测传输数据寄存器空标志
  117.     while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
  118. }
  120. // 发送8位数据的数组
  121. void Usart_SendArray(USART_TypeDef* pUSARTx, uint8_t *array, uint8_t num)
  122. {
  123.     uint8_t i;
  124.     for(i=0; i<num; i++)
  125.     {
  126.         // 循环发送1个字节的数据
  127.         Usart_SendByte(pUSARTx, array[i]);
  128.     }
  130.     // 检测传输完成标志
  131.     while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET);    
  132. }
  135. // 发送字符串
  136. void Usart_SendStr(USART_TypeDef* pUSARTx, uint8_t *str)
  137. {
  138.     uint8_t i=0;
  139.     do
  140.     {
  141.         Usart_SendByte(pUSARTx, *(str + i));
  142.         i++;
  144.     }while(*(str+i) != '\0'); // 当为字符串的结束字符时，则停止发送
  146.     // 检测传输完成标志
  147.     while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET);
  148. }
  151. // 重定向c库函数printf到串口，重定向后可使用printf函数
  152. int fputc(int ch, FILE *f)
  153. {
  154.     // 发送一个字节数据到串口
  155.     USART_SendData(DEBUG_USARTx, (uint8_t) ch);
  157.     // 等待发送完毕
  158.     while(USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);
  160.     return ch;
  161. }
  164. // 重定向c库函数scanf到串口，重定向后可使用scan/getchar函数
  165. int fgetc(FILE *f)
  166. {
  168.     // 等待串口输入数据
  169.     while(USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_RXNE) == RESET);
  171.     // 将数据返回
  172.     return (int)USART_ReceiveData(DEBUG_USARTx);
  173. }
  177. /*-------------- 串口服务中断函数 当接收的外部发送的数据时，中断会进行响应--------------*/
  178. void DEBUG_USART_IRQHandler(void)
  179. {
  180.     uint8_t ucTemp;
  181.     if(USART_GetITStatus(DEBUG_USARTx, USART_IT_RXNE) != RESET)
  182.     {
  183.         // 临时变量，用来存储接收串口发来的数据
  184.         ucTemp = USART_ReceiveData(DEBUG_USARTx);
  186.         // 返回发送的数据
  187.         USART_SendData(DEBUG_USARTx, ucTemp);
  188.     }
  189. }

main.c

  1. /**********************
  2. 芯片：STM32F103C8T6
  4. 实现功能：串口收发送数据
  6. 引脚：
  7. ***********************/
  9. #include "stm32f10x.h"
  10. #include "bsp_usart.h"
  13. int main(void)
  14. {
  15.     // 10个数据的数组
  16.     uint8_t data_arr[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
  18.     // 初始化USART
  19.     USART_Config();
  21.     // 向串口发送数据
  22.     // Usart_SendByte(DEBUG_USARTx, 0x64); // 发送一个字节的数据
  23.     // Usart_SendHalfWold(DEBUG_USARTx, 0x8889); // 发送2个字节的数据
  24.     // Usart_SendArray(DEBUG_USARTx, data_arr, 10); // 发送一个数组的数据
  25.     // Usart_SendStr(DEBUG_USARTx, "欢迎使用\n"); // 发送字符串
  26.     // printf("串口printf函数测试"); // 使用c库函数发送字符串 //相对应的是scanf()函数
  27.     // putchar('p'); // 使用c库函数发送一个字符 //相对于的是getchar()函数
  29.     while(1)
  30.     {
  32.     }
  33. }

使用串口来控制LED灯

bsp_led.h

  1. #ifndef    __BSP_LED_H
  2. #define __BSP_LED_H
  5. #include "stm32f10x.h"
  8. #define        LED_GPIO_PORT                        GPIOB
  9. #define        LED0_GPIO_PIN                        GPIO_Pin_0
  10. #define        LED1_GPIO_PIN                        GPIO_Pin_1
  11. #define        LED5_GPIO_PIN                        GPIO_Pin_5
  13. #define OFF        0
  14. #define    ON        1
  16. #define LED0_TOGGLE                (LED_GPIO_PORT->ODR ^= LED0_GPIO_PIN)  // 改变odr输出的状态
  17. #define LED1_TOGGLE                (LED_GPIO_PORT->ODR ^= LED1_GPIO_PIN)  // 改变odr输出的状态
  18. #define LED2_TOGGLE                (LED_GPIO_PORT->ODR ^= LED5_GPIO_PIN)  // 改变odr输出的状态
  20. #define LED0(a)    if(a)        GPIO_ResetBits(LED_GPIO_PORT, LED0_GPIO_PIN); \
  21.                                 else GPIO_SetBits(LED_GPIO_PORT, LED0_GPIO_PIN);
  23. #define LED1(a)    if(a)        GPIO_ResetBits(LED_GPIO_PORT, LED1_GPIO_PIN); \
  24.                                 else GPIO_SetBits(LED_GPIO_PORT, LED1_GPIO_PIN);
  26. #define LED2(a)    if(a)        GPIO_ResetBits(LED_GPIO_PORT, LED5_GPIO_PIN); \
  27.                                 else GPIO_SetBits(LED_GPIO_PORT, LED5_GPIO_PIN);
  29. void LED_GPIO_Config(void);
  31. #endif //__BSP_LED_H

bsp_led.c

  1. // bsp: board support package 板级支持包
  2. #include "bsp_led.h"
  4. void LED_GPIO_Config(void)
  5. {
  6.     // 初始化结构体
  7.     GPIO_InitTypeDef    GPIO_InitStruct;
  8.     //LED_GPIO_CLK_ENABLE;
  9.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
  10.     // 初始化
  11.     GPIO_InitStruct.GPIO_Pin |= LED0_GPIO_PIN;
  12.     GPIO_InitStruct.GPIO_Pin |= LED1_GPIO_PIN;
  13.     GPIO_InitStruct.GPIO_Pin |= LED5_GPIO_PIN;
  14.     GPIO_InitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
  15.     GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
  17.     GPIO_Init(LED_GPIO_PORT, &GPIO_InitStruct);
  19. }

bsp_usart.h

  1. // 与使用向串口发送和接收数据实例的 bsp_usart.h头文件一样

bsp_usart.c

  1. #include "bsp_usart.h"
  4. /*
  5.  * 要取消中断服务，不然会影响收的数据
  6. */
  7. //// 中断控制器NVIC配置
  8. //static void NVIC_Configuration(void)
  9. //{
  10. //    
  11. //  NVIC_InitTypeDef NVIC_InitStructure;
  13. //  /* 嵌套向量中断控制器组选择 */
  14. //  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  16. //  /* 配置 USART 为中断源 */
  17. //  NVIC_InitStructure.NVIC_IRQChannel = DEBUG_USART_IRQ;
  18. //    
  19. //  /* 抢断优先级为 1 */
  20. //  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
  21. //    
  22. //  /* 子优先级为 1 */
  23. //  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  24. //    
  25. //  /* 使能中断 */
  26. //  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  27. //    
  28. //  /* 初始化配置 NVIC */
  29. //  NVIC_Init(&NVIC_InitStructure);
  30. //}
  34. // USART初始化配置
  35. void USART_Config(void)
  36. {
  37.   GPIO_InitTypeDef        GPIO_InitStructure;
  38.     USART_InitTypeDef        USART_InitStructure;
  40.     // 打开串口GPIO的时钟
  41.     DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
  43.   // 打开串口外设的时钟
  44.   DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);
  46.   // 将 USART Tx 的 GPIO 配置为推挽复用模式
  47.   GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
  48.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  49.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  50.   GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);
  52.   // 将 USART Rx 的 GPIO 配置为浮空输入模式
  53.   GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
  54.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  55.   GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);
  57.   // 配置串口的工作参数
  58.   // 配置波特率
  59.   USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
  61.     // 配置 针数据字长
  62.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  64.     // 配置停止位
  65.   USART_InitStructure.USART_StopBits = USART_StopBits_1;
  67.   // 配置校验位
  68.   USART_InitStructure.USART_Parity = USART_Parity_No ;
  70.   // 配置硬件流控制
  71.   USART_InitStructure.USART_HardwareFlowControl =
  72.   USART_HardwareFlowControl_None;
  74.     // 配置工作模式，收发一起
  75.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  77.   // 完成串口的初始化配置
  78.   USART_Init(DEBUG_USARTx, &USART_InitStructure);
  81. /*
  82.  * 要取消中断服务，不然会影响收的数据
  83. */
  84. //  // 串口中断优先级配置
  85. //  NVIC_Configuration();
  87. //  // 使能串口接收中断
  88. //  USART_ITConfig(DEBUG_USARTx, USART_IT_RXNE, ENABLE);
  93.   // 使能串口
  94.   USART_Cmd(DEBUG_USARTx, ENABLE);
  95. }
  97. // 给串口发送数据
  98. void Usart_SendByte(USART_TypeDef* pUSARTx, uint8_t data)
  99. {
  100.     // 发送数据
  101.     USART_SendData(pUSARTx, data);
  103.     // 检测传输数据寄存器空标志
  104.     while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
  105. }    
  108. // 给串口发送数据
  109. void Usart_SendHalfWold(USART_TypeDef* pUSARTx, uint16_t data)
  110. {
  111.     uint8_t temp_h, temp_l;
  113.     // 高8位
  114.     temp_h = (data & 0xff00) >> 8;
  116.     // 低8位
  117.     temp_l = data & 0xff;
  120.     /* 发送高8位数据 */
  121.     USART_SendData(pUSARTx, temp_h);
  123.     // 检测传输数据寄存器空标志
  124.     while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
  126.     /* 发送低8位数据 */
  127.     USART_SendData(pUSARTx, temp_l);
  129.     // 检测传输数据寄存器空标志
  130.     while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);
  132. }    
  135. // 发送8位数据的数组
  136. void Usart_SendArray(USART_TypeDef* pUSARTx, uint8_t *array, uint8_t num)
  137. {
  138.     uint8_t i;
  139.     for(i=0; i<num; i++)
  140.     {
  141.         // 循环发送1个字节的数据
  142.         Usart_SendByte(pUSARTx, array[i]);
  143.     }
  145.     // 检测传输完成标志
  146.     while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET);    
  147. }
  150. // 发送字符串
  151. void Usart_SendStr(USART_TypeDef* pUSARTx, uint8_t *str)
  152. {
  153.     uint8_t i=0;
  154.     do
  155.     {
  156.         Usart_SendByte(pUSARTx, *(str + i));
  157.         i++;
  159.     }while(*(str+i) != '\0'); // 当为字符串的结束字符时，则停止发送
  161.     // 检测传输完成标志
  162.     while(USART_GetFlagStatus(pUSARTx, USART_FLAG_TC) == RESET);
  163. }
  166. // 重定向c库函数printf到串口，重定向后可使用printf函数
  167. int fputc(int ch, FILE *f)
  168. {
  169.     // 发送一个字节数据到串口
  170.     USART_SendData(DEBUG_USARTx, (uint8_t) ch);
  172.     // 等待发送完毕
  173.     while(USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);
  175.     return ch;
  176. }
  179. // 重定向c库函数scanf到串口，重定向后可使用scan/getchar函数
  180. int fgetc(FILE *f)
  181. {
  183.     // 等待串口输入数据
  184.     while(USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_RXNE) == RESET);
  186.     // 将数据返回
  187.     return (int)USART_ReceiveData(DEBUG_USARTx);
  188. }
  191. /*
  192.  * 要取消中断服务，不然会影响收的数据
  193. */
  194. //// 串口服务中断
  195. //void DEBUG_USART_IRQHandler(void)
  196. //{
  197. //    uint8_t ucTemp;
  198. //    if(USART_GetITStatus(DEBUG_USARTx, USART_IT_RXNE) != RESET)
  199. //    {
  200. //        // 临时变量，用来存储接收串口发来的数据
  201. //        ucTemp = USART_ReceiveData(DEBUG_USARTx);
  202. //        
  203. //        // 返回发送的数据
  204. //        USART_SendData(DEBUG_USARTx, ucTemp);
  205. //    }
  206. //}

main.c

  1. /**********************
  2. 芯片：STM32F103C8T6
  4. 实现功能：使用串口给单片机发数据从而改变三个led灯的状态
  6. 引脚：
  7. ***********************/
  9. #include "stm32f10x.h"
  10. #include "bsp_usart.h"
  11. #include "bsp_led.h"
  13. int main(void)
  14. {
  16.     uint8_t ch; // 用于存储串口发送来的数据
  18.     // 初始化USART
  19.     USART_Config();
  21.     // 初始化LED
  22.     LED_GPIO_Config(); 
  25.     while(1)
  26.     {
  27.         ch = getchar(); // 获取返回来的数据
  28.         printf("ch=%c\n", ch);
  30.         switch(ch)
  31.         {
  32.             case '1': LED0_TOGGLE; // 控制LED0的状态
  33.                 break;
  34.             case '2': LED1_TOGGLE; // 控制LED1的状态
  35.                 break;
  36.             case '3': LED2_TOGGLE; // 控制LED2的状态
  37.                 break;
  38.         }
  39.     }
  40. }

DMA直接存储器存取

DMA_InitTypeDef初始化结构体解析

  1. typedef struct
  2. {
  3.     /*------------------ 数据从哪里来，要到哪里去 ------------------------------- */
  4.     uint32_t DMA_PeripheralBaseAddr;    // 外设地址   DMA_CPAR
  5.     uint32_t DMA_MemoryBaseAddr;        // 存储器地址 DMA_CMAR
  6.     uint32_t DMA_DIR;                    // 传输方向   DMA_CCR:DIR
  8.     /*------------------ 数据要传多少，传的单位是什么 ---------------------------- */
  9.     uint32_t DMA_BufferSize;            // 传输数目              DMA_CNDTR
  10.     uint32_t DMA_PeripheralInc;            // 外设地址增量模式       DMA_CCRx:PINC
  11.     uint32_t DMA_MemoryInc;                // 存储器地址增量模式  DMA_CCRx:MINC
  12.     uint32_t DMA_PeripheralDataSize;    // 外设数据宽度        DMA_CCRx:PSIZE
  13.     uint32_t DMA_MemoryDataSize;        // 存储器数据宽度       DMA_CCRx:MSIZE
  15.     /*------------------ 什么时候传输结束 ---------------------------- */
  16.     uint32_t DMA_Mode;                    // 模式选择        DMA_CCRx:CIRC
  18.     uint32_t DMA_Priority;                // 通道优先级
  19.     uint32_t DMA_M2M;                    // 存储器到存储器模式
  20. }DMA_InitTypeDef;

DMA存储器到存储器传输实例

bsp_dma.h

  1. #ifndef __BSP_DMA_H
  2. #define __BSP_DMA_H
  4. #include "stm32f10x.h"
  7. // 要发送的数据大小
  8. #define BUFFER_SIZE     32
  10. #define  MTM_DMA_CLK       RCC_AHBPeriph_DMA1      // 选择DMA时钟
  11. #define  MTM_DMA_CHANNEL   DMA1_Channel6          // 选择6通道
  12. #define  MTM_DMA_FLAG_TC   DMA1_FLAG_TC6          // DMA1通道6传输完成标志
  14. void MtoM_DMA_Config(void);
  15. uint8_t Buffercmp(const uint32_t* pBuffer, 
  16.                   uint32_t* pBuffer1, uint16_t BufferLength);
  19. #endif // __BSP_DMA_H

bsp_dma.c

  1. #include "bsp_dma.h"
  4. /* 定义aSRC_Const_Buffer数组作为DMA传输数据源
  5.  * const关键字将aSRC_Const_Buffer数组变量定义为常量类型
  6.  * 表示数据存储在内部的FLASH中
  7.  */
  8. const uint32_t aSRC_Const_Buffer[BUFFER_SIZE]= {
  9.                                     0x01020304,0x05060708,0x090A0B0C,0x0D0E0F10,
  10.                                     0x11121314,0x15161718,0x191A1B1C,0x1D1E1F20,
  11.                                     0x21222324,0x25262728,0x292A2B2C,0x2D2E2F30,
  12.                                     0x31323334,0x35363738,0x393A3B3C,0x3D3E3F40,
  13.                                     0x41424344,0x45464748,0x494A4B4C,0x4D4E4F50,
  14.                                     0x51525354,0x55565758,0x595A5B5C,0x5D5E5F60,
  15.                                     0x61626364,0x65666768,0x696A6B6C,0x6D6E6F70,
  16.                                     0x71727374,0x75767778,0x797A7B7C,0x7D7E7F80};
  18. /* 定义DMA传输目标存储器
  19.  * 存储在内部的SRAM中                                                                        
  20.  */
  21. uint32_t aDST_Buffer[BUFFER_SIZE];
  25. void MtoM_DMA_Config(void)
  26. {
  27.     // 初始化结构体
  28.     DMA_InitTypeDef DMA_InitStruct;
  30.     // 打开时钟
  31.     RCC_AHBPeriphClockCmd(MTM_DMA_CLK, ENABLE);
  33.     // 
  34.     DMA_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)aSRC_Const_Buffer;  // 外设地址
  35.     DMA_InitStruct.DMA_MemoryBaseAddr = (uint32_t)aDST_Buffer;              // 存储器地址
  36.     DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;                                                // 传输方向
  38.     DMA_InitStruct.DMA_BufferSize = BUFFER_SIZE;                             // 传输数目
  40.     DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Enable;          // 外设地址增量模式
  41.     DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;  // 外设数据宽度
  42.     DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;                  // 存储器地址增量模式
  43.     DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;          // 外设数据宽度
  45.     DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;                                                        // 模式选择
  46.     DMA_InitStruct.DMA_Priority = DMA_Priority_High;                                            // 通道优先级
  47.     DMA_InitStruct.DMA_M2M = DMA_M2M_Enable;                                                            // 存储器到存储器模式
  49.     // 初始化 
  50.     DMA_Init(MTM_DMA_CHANNEL, &DMA_InitStruct);
  52.     // 标志触发器清零
  53.     DMA_ClearFlag(MTM_DMA_FLAG_TC);
  55.     // 使能DMA
  56.     DMA_Cmd(MTM_DMA_CHANNEL, ENABLE);
  57. }
  61. /**
  62.   * 判断指定长度的两个数据源是否完全相等，
  63.   * 如果完全相等返回1，只要其中一对数据不相等返回0
  64.   */
  65. uint8_t Buffercmp(const uint32_t* pBuffer, 
  66.                   uint32_t* pBuffer1, uint16_t BufferLength)
  67. {
  68.   /* 数据长度递减 */
  69.   while(BufferLength--)
  70.   {
  71.     /* 判断两个数据源是否对应相等 */
  72.     if(*pBuffer != *pBuffer1)
  73.     {
  74.       /* 对应数据源不相等马上退出函数，并返回0 */
  75.       return 0;
  76.     }
  77.     /* 递增两个数据源的地址指针 */
  78.     pBuffer++;
  79.     pBuffer1++;
  80.   }
  81.   /* 完成判断并且对应数据相对 */
  82.   return 1;  
  83. }

bsp_led.h

  1. // bsp_led.h和bsp_led.c文件参照之前的

main.c

  1. /**********************
  2. 芯片：STM32F103C8T6
  4. 实现功能：存储器到存储器传输实例 传输成功后亮成功的led灯，失败亮失败的led灯
  6. 引脚：
  7. ***********************/
  9. #include "stm32f10x.h"
  10. #include "bsp_dma.h"
  11. #include "bsp_led.h"
  13. // 声明两个外部文件来的变量 extern表示导入外部的变量(非头文件里的)
  14. extern const uint32_t aSRC_Const_Buffer[BUFFER_SIZE];
  15. extern uint32_t aDST_Buffer[BUFFER_SIZE];
  18. int main(void)
  19. {
  21.     uint8_t status = 0;
  23.     // 初始化LED
  24.     LED_GPIO_Config();
  26.     // 将3个led都熄灭，因为程序初始化后led灯默认都点亮的
  27.     LED0(OFF);
  28.     LED1(OFF);
  29.     LED2(OFF);
  31.     // 初始化MtoM_DMA_Config
  32.     MtoM_DMA_Config();
  34.     // 检测传输是否完成
  35.     while(DMA_GetFlagStatus(MTM_DMA_FLAG_TC) == RESET);
  37.     // 比较函数，比较目标的数据和传输后存储的数据是否相同
  38.     status = Buffercmp(aSRC_Const_Buffer, aDST_Buffer, BUFFER_SIZE);
  40.     if(0 == status)
  41.     {
  42.         LED0(ON); // 失败亮led0
  43.     }
  44.     else
  45.     {
  46.         LED1(ON); // 成功亮led1
  47.     }
  50.     while(1)
  51.     {
  53.     }
  54. }

使用串口进行DMA传输(M To P)

bsp_dma_mtp.h

  1. #ifndef __BSP_DMA_MTP_H
  2. #define __BSP_DMA_MTP_H
  4. #include "stm32f10x.h"
  5. #include <stdio.h>
  7. // 串口工作参数宏定义
  8. #define  DEBUG_USARTx                   USART1
  9. #define  DEBUG_USART_CLK                RCC_APB2Periph_USART1
  10. #define  DEBUG_USART_APBxClkCmd         RCC_APB2PeriphClockCmd
  11. #define  DEBUG_USART_BAUDRATE           115200
  13. // USART GPIO 引脚宏定义
  14. #define  DEBUG_USART_GPIO_CLK           (RCC_APB2Periph_GPIOA)
  15. #define  DEBUG_USART_GPIO_APBxClkCmd    RCC_APB2PeriphClockCmd
  17. #define  DEBUG_USART_TX_GPIO_PORT       GPIOA   
  18. #define  DEBUG_USART_TX_GPIO_PIN        GPIO_Pin_9
  19. #define  DEBUG_USART_RX_GPIO_PORT       GPIOA
  20. #define  DEBUG_USART_RX_GPIO_PIN        GPIO_Pin_10
  22. #define  USART_TX_DMA_CLK               RCC_AHBPeriph_DMA1        
  23. #define  USART_TX_DMA_CHANNEL           DMA1_Channel4        // 选择第4通道
  24. #define  USART_TX_DMA_FLAG_TC           DMA1_FLAG_TC4
  25. #define  USART_DR_ADDRESS              (USART1_BASE+0x04)   // 外设寄存地址
  28. #define  SENDBUFF_SIZE          5000
  30. void USARTx_DMA_Config(void);
  31. void USART_Config(void);
  33. #endif  /* __BSP_DMA_MTP_H */

bsp_dma_mtp.c

  1. #include "bsp_dma_mtp.h"
  4. // 定义存储变量
  5. uint8_t SendBuff[SENDBUFF_SIZE];
  7. /**
  8.   * @brief  USART GPIO 配置,工作参数配置
  9.   * @param  无
  10.   * @retval 无
  11.   */
  13. void USART_Config()
  14. {
  15.     GPIO_InitTypeDef   GPIO_InitStructure;
  16.     USART_InitTypeDef  USART_InitStructure;
  18.     // 打开串口GPIO的时钟
  19.     DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
  21.     // 打开串口外设的时钟
  22.     DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);
  24.     // 将USART Tx的GPIO配置为推挽复用模式
  25.     GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
  26.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  27.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  28.     GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);
  30.   // 将USART Rx的GPIO配置为浮空输入模式
  31.     GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
  32.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  33.     GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);
  35.     // 配置串口的工作参数
  36.     // 配置波特率
  37.     USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
  38.     // 配置 针数据字长
  39.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  40.     // 配置停止位
  41.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
  42.     // 配置校验位
  43.     USART_InitStructure.USART_Parity = USART_Parity_No ;
  44.     // 配置硬件流控制
  45.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  46.     // 配置工作模式，收发一起
  47.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  48.     // 完成串口的初始化配置
  49.     USART_Init(DEBUG_USARTx, &USART_InitStructure);    
  51.     // 使能串口
  52.     USART_Cmd(DEBUG_USARTx, ENABLE);
  53. }
  55. // 重定向c库函数printf到串口，重定向后可使用printf函数
  56. int fputc(int ch, FILE *f)
  57. {
  58.     /* 发送一个字节数据到串口 */
  59.     USART_SendData(DEBUG_USARTx, (uint8_t) ch);
  61.     /* 等待发送完毕 */
  62.     while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);        
  64.     return (ch);
  65. }
  67. // Memory -> P (USART->DR)
  68. void USARTx_DMA_Config(void)
  69. {
  70.     DMA_InitTypeDef DMA_InitStruct;
  72.     RCC_AHBPeriphClockCmd(USART_TX_DMA_CLK, ENABLE);
  74.     DMA_InitStruct.DMA_PeripheralBaseAddr = (uint32_t)USART_DR_ADDRESS;
  75.     DMA_InitStruct.DMA_MemoryBaseAddr = (uint32_t)SendBuff;
  76.     DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralDST;
  78.     DMA_InitStruct.DMA_BufferSize = SENDBUFF_SIZE;
  80.     DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  81.     DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;    
  82.     DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
  83.     DMA_InitStruct.DMA_MemoryDataSize = DMA_PeripheralDataSize_Byte;
  85.     DMA_InitStruct.DMA_Mode = DMA_Mode_Normal; // 表示传完一次就结束，DMA_Mode_Circular表示传完继续循环传
  86.     DMA_InitStruct.DMA_Priority = DMA_Priority_High;
  87.     DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
  89.     DMA_Init(USART_TX_DMA_CHANNEL, &DMA_InitStruct);
  91.     DMA_ClearFlag(USART_TX_DMA_FLAG_TC);
  92.     DMA_Cmd(USART_TX_DMA_CHANNEL, ENABLE);
  93. }

main.c

  1. /**********************
  2. 芯片：STM32F103C8T6
  4. 实现功能：使用串口进行DMA传输(M To P)
  6. 引脚：
  7. ***********************/
  9. #include "stm32f10x.h"
  10. #include "bsp_dma_mtp.h"
  11. #include "bsp_led.h"
  13. extern uint8_t SendBuff[SENDBUFF_SIZE];
  15. // 软件延时
  16. #define SOFT_DELAY Delay(0x0FFFFF);
  17. void Delay(__IO u32 nCount); 
  19. int main(void)
  20. {
  22.     uint16_t i=0;
  24.     // 初始化LED
  25.     LED_GPIO_Config();
  27.     // 初始化串口
  28.     USART_Config();
  30.     // 将3个led都熄灭，因为程序初始化后led灯默认都点亮的
  31.     LED0(OFF);
  32.     LED1(OFF);
  33.     LED2(OFF);
  35.     // 初始化SendBuff内的值
  36.     for(i=0; i<SENDBUFF_SIZE; i++)
  37.     {
  38.         SendBuff[i] = 'P';
  39.     }
  41.     // 初始化DMA
  42.   USARTx_DMA_Config();
  44.     // DMA使能
  45.     USART_DMACmd(DEBUG_USARTx, USART_DMAReq_Tx, ENABLE);
  48.     while(1)
  49.     {
  50.         // 用于观察当串口向DMA写数据时，观察DMA是否是异步运行的
  51.         LED0_TOGGLE;
  52.     Delay(0xFFFFF);
  53.     }
  54. }
  57. void Delay(__IO uint32_t nCount)     //简单的延时函数
  58. {
  59.     for(; nCount != 0; nCount--);
  60. }