bsp_DMAusart1.h

  1. #ifndef __BSP_DMAUSART1_H
  2. #define    __BSP_DMAUSART1_H
  3. //-------------------------------------------------------------------
  5. #include "stm32f10x.h"
  6. #include <string.h>
  7. //-------------------------------------------------------------------
  8. #define USART1_REC_LEN              58      //定义最大接收字节数 58
  10. typedef struct
  11. {
  12.     uint8_t Tx_buf[USART1_REC_LEN];      //发送缓冲区
  13.     uint8_t Tx_len;                      //发送长度
  15.     uint8_t Rx_buf[USART1_REC_LEN];      //接收缓冲区
  16.     uint8_t Rx_len;                      //接收长度
  17.     uint8_t Rx_end_flag;              //接收完成标志
  18.     uint8_t Rx_time_start;            //计时启动标志
  19.     uint16_t Rx_time;                 //1祯数据接收时长(mSec) 
  20. }USART1_DEF;
  21. extern USART1_DEF OneUART;
  25. //-------------------------------------------------------------------
  26. void USART1_Init(uint32_t BAND,uint8_t *SendAddres,uint8_t *RecAddres,uint8_t len);
  27. void DMA_USART1RxTx_Init(uint8_t *SendAd,uint8_t *RecAddres,uint8_t len);
  28. void NVIC_USART1_Configuration(void);
  32. void USART1_SendChar(u8 t);
  33. void USART_printf(USART_TypeDef* USARTx, uint8_t *Data,...);
  34. void USART1_SendString(void* buffer, uint16_t size);
  35. void USART1_Encryption_SendString(void* buffer, uint16_t size);
  37. uint16_t USART1_DMASendString(void* buffer, uint16_t size);
  38. uint16_t USART1_Encryption_DMASendString(void* buffer, uint16_t size);
  40. #endif /* __USART1_H */

bsp_DMAusart1.c

  1. #include "bsp_DMAusart1.h"
  3. USART1_DEF OneUART;
  4. /**
  5. * @brief  USART1初始化
  6. * @param  BAND,波特率(2400,4800,9600,38400,115200)
  7. *         Send_pf,发送数据缓冲区
  8. *         Rec_pf,接收数据缓冲区
  9. *         buf_len,接收数据缓冲区长度
  10. * @retval 无
  11. */
  12. void USART1_Init(uint32_t BAND,uint8_t *Send_pf,uint8_t *Rec_pf,uint8_t buf_len)
  13. {
  14.     GPIO_InitTypeDef GPIO_InitStructure;
  15.     USART_InitTypeDef USART_InitStructure;
  17.     /* config USART1 clock */
  18.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOB, ENABLE);
  20.     /* USART1 GPIO config */
  22.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);//使能端口重映射
  24.     /* Configure USART1 Tx (PB6) as alternate function push-pull */
  25.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
  26.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  27.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  28.     GPIO_Init(GPIOB, &GPIO_InitStructure);
  30.     /* Configure USART1 Rx (PB7) as input floating */
  31.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
  32.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  33.     GPIO_Init(GPIOB, &GPIO_InitStructure);
  35.      /* RS485,Tx/Rx Control PB5 */
  36.      GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_5;
  37.      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  38.      GPIO_Init(GPIOB, &GPIO_InitStructure);
  39.     GPIO_ResetBits(GPIOB,GPIO_Pin_5);
  41.     GPIO_PinRemapConfig(GPIO_Remap_USART1,ENABLE);    
  44.     /* USART1 mode config */
  45.     USART_InitStructure.USART_BaudRate = BAND;
  46.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  47.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
  48.     USART_InitStructure.USART_Parity = USART_Parity_No ;
  49.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  50.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  52.     USART_Init(USART1, &USART_InitStructure); 
  53.     USART_Cmd(USART1, ENABLE);
  57.     USART_ClearFlag(USART1, USART_FLAG_TC);             //清发送完成标志
  58.     USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);        //开启空闲中断
  59.     USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);        //开启接收中断
  60.     USART_ITConfig(USART1, USART_IT_TC, ENABLE);        //开启发送完成中断
  61.     NVIC_USART1_Configuration();
  63.     DMA_USART1RxTx_Init(Send_pf,Rec_pf,buf_len);//DMA初始化
  65. }
  68. /**
  69. * @brief  配置USART1中断
  70. * @param  
  71. * @retval 无
  72. */
  73. static void NVIC_USART1_Configuration(void)
  74. {
  75.     NVIC_InitTypeDef NVIC_InitStructure; 
  76.     /* Configure the NVIC Preemption Priority Bits */  
  77.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
  79.     /* Enable the USARTy Interrupt */
  80.     NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;         //开启接收完成中断
  81.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  82.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
  83.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  84.     NVIC_Init(&NVIC_InitStructure);
  86.     NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
  88.     /* Enable the USARTy Interrupt */
  89.     NVIC_InitStructure.NVIC_IRQChannel = DMA1_Channel4_IRQn;//开启发送完成中断 
  90.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  91.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
  92.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  93.     NVIC_Init(&NVIC_InitStructure);
  94. }
  96. /**
  97. * @brief  DMA_USART1初始化
  98. * @param  Send_pf,发送数据缓冲区
  99. *         Rec_pf,接收数据缓冲区
  100. *         buf_len,接收数据缓冲区长度
  101. * @retval 无
  102. */
  103. static void DMA_USART1RxTx_Init(uint8_t *Send_pf,uint8_t *Rec_pf,uint8_t buf_len)
  104. {    
  105.     DMA_InitTypeDef DMA_InitStructure;
  106.     RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
  107.     DMA_Cmd(DMA1_Channel5,DISABLE);                                             //关闭DMA
  108.     DMA_DeInit(DMA1_Channel5);                                                    //恢复默认
  109.     DMA_InitStructure.DMA_PeripheralBaseAddr=(u32)&USART1->DR;                    //设置串口发送数据寄存器            
  110.     DMA_InitStructure.DMA_MemoryBaseAddr=(u32)Rec_pf;                             //设置发送缓冲区首地址        
  111.     DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;                            //设置外设位目标，内存缓冲区 <- 外设寄存器
  112.     DMA_InitStructure.DMA_BufferSize=buf_len;                                    //需要发送的字节数，这里其实可以设置为0，因为在实际要发送的时候，会重新设置次值
  113.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;            //外设地址不递增
  114.     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;                        //内存递增
  115.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;        //外设字节宽度
  116.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;                //内存字节宽度
  117.     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;                                 //正常模式 
  118.     DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;                        //高优先级
  119.     DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;                                 //关闭内存到内存的DMA模式
  120.     DMA_Init(DMA1_Channel5,&DMA_InitStructure);                                 //配置DMA1的6通道 
  121.     DMA_Cmd(DMA1_Channel5,ENABLE);                                              //使能DMA
  123.     DMA_DeInit(DMA1_Channel4);
  124.     DMA_InitStructure.DMA_PeripheralBaseAddr= (u32)&USART1->DR;                    //初始化外设地址            
  125.     DMA_InitStructure.DMA_MemoryBaseAddr=(u32)Send_pf;                             //内存地址        
  126.     DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;                            //外设作为数据来源
  127.     DMA_InitStructure.DMA_BufferSize=0;                                            //发送长度为0
  128.     DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;            //外设地址不递增
  129.     DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;                        //内存递增
  130.     DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;        //外设字节宽度
  131.     DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;                //内存字节宽度
  132.     DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;                                 //正常模式 
  133.     DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;                        //高优先级
  134.     DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;                                 //关闭内存到内存的DMA模式    
  135.     DMA_Init(DMA1_Channel4,&DMA_InitStructure);                                 //配置DMA1的7通道
  136.     DMA_Cmd(DMA1_Channel4,ENABLE);                                              //使能DMA
  138.     USART_ITConfig(USART1, USART_DMAReq_Tx, ENABLE);                               //开启中断USART_DMAReq_Tx
  139.     USART_DMACmd(USART1,USART_DMAReq_Rx,ENABLE);                                  //开启接收接收
  140.     USART_DMACmd(USART1,USART_DMAReq_Tx,ENABLE);                                  //开启接收发送
  141. //    DMA_ITConfig(DMA1_Channel4,DMA_IT_TC,ENABLE);                               //配置DMA发送完成后产生中断
  143. }
  144.  /**
  145.   * @brief  USART1_DMA发送完成中断
  146.   * @param  无
  147.   * @retval 无
  148.   */
  149. void DMA1_Channel4_IRQHandler(void)
  150. {
  151.     if(DMA_GetFlagStatus(DMA1_FLAG_TC4)!=RESET)
  152.     {//发送完成中断
  153.         DMA_ClearFlag(DMA1_FLAG_TC4);
  154.         //GPIO_ResetBits(GPIOB,GPIO_Pin_5);
  155.     }
  156. }
  157.  /**
  158.   * @brief  USART1串口接收中断
  159.   * @param  无
  160.   * @retval 无
  161.   */
  162. void USART1_IRQHandler(void)                    //串口1中断服务程序
  163. {
  164.     static uint8_t LEN=0;
  165.     uint8_t Clear=Clear,tmp;
  166.     if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) 
  167.     {//接收中断     
  168.         OneUART.Rx_buf[LEN++]= USART1->DR;            //读取接收到的数据
  169.         LEN= (LEN < USART1_REC_LEN)?LEN:0;
  170.     }else if(USART_GetITStatus(USART1, USART_IT_IDLE) != RESET)
  171.     {//空闲中断，1桢数据接收完毕
  172.         Clear=USART1->SR;    //读SR寄存器
  173.         Clear=USART1->DR;    //读DR寄存器，(先读SR，再读DR就是清除IDLE标志中断)
  174.         OneUART.Rx_end_flag  = 1;                //接收完成标志
  175.         DMA_Cmd(DMA1_Channel5,DISABLE); 
  176.         OneUART.Rx_len=USART1_REC_LEN-DMA_GetCurrDataCounter(DMA1_Channel5);
  177.         DMA_SetCurrDataCounter(DMA1_Channel5,USART1_REC_LEN); //设置DMA缓冲区长度
  178.         DMA_Cmd(DMA1_Channel5,ENABLE);    
  179.     }else if(USART_GetITStatus(USART1, USART_IT_TC) != RESET)    
  180.     {//发送完成中断 
  181.         USART_ClearITPendingBit(USART1, USART_IT_TC);    //清除USART1发送完成中断标志
  182.         DMA_ClearFlag(DMA1_FLAG_TC4);                    //清零标志位
  183.         GPIO_ResetBits(GPIOB,GPIO_Pin_5);                //发送完成，等待接收数据
  185.     }
  186. }
  187.  /**
  188.   * @brief  DMA_USART1数据发送
  189.   * @param  buffer,发送数据地址
  190.   *         size,发送数据长度
  191.   * @retval size
  192.   */
  193. uint16_t USART1_DMASendString(void* buffer, uint16_t size)
  194. {
  195.       if(!size) return 0;                                                    //判断长度是否有效
  196.       while(DMA_GetCurrDataCounter(DMA1_Channel4));                            //检查DMA通道内是否还有数据
  197.       if(buffer) //发送数据拷贝到发送缓存区
  198.           memcpy(OneUART.Tx_buf, buffer,(size > 1024?1024:size));    
  199.       DMA_Cmd(DMA1_Channel4, DISABLE);                                        //DMA发送数据要先关闭，设置发送数据长度  开启DMA
  200.       DMA1_Channel4->CNDTR = size;                                            //设置发送长度
  201.       GPIO_SetBits(GPIOB,GPIO_Pin_5); 
  202.       DMA_Cmd(DMA1_Channel4, ENABLE);                                          //启动DMA发送
  203.       return size;
  204. }
  205.  /**
  206.   * @brief  DMA_USART1加密数据发送
  207.   * @param  buffer,发送数据地址
  208.   *         size,发送数据长度
  209.   * @retval size
  210.   */
  211. uint16_t USART1_Encryption_DMASendString(void* buffer, uint16_t size)
  212. {
  213.       if(!size) return 0;                                                    //判断长度是否有效
  214.       while(DMA_GetCurrDataCounter(DMA1_Channel4));                            //检查DMA通道内是否还有数据
  215.       if(buffer) //发送数据拷贝到发送缓存区
  216.       {
  217.           //encryption(buffer,size);//使能加密
  218.           memcpy(OneUART.Tx_buf, buffer,(size > 1024?1024:size));    
  219.       }     
  220.       DMA_Cmd(DMA1_Channel4, DISABLE);                                        //DMA发送数据要先关闭，设置发送数据长度  开启DMA
  221.       DMA1_Channel4->CNDTR = size;                                            //设置发送长度
  222.       GPIO_SetBits(GPIOB,GPIO_Pin_5); 
  223.       DMA_Cmd(DMA1_Channel4, ENABLE);                                          //启动DMA发送
  224.       return size;
  225. }
  229.  /**
  230.   * @brief  USART1发送数据1个字节
  231.   * @param  dat,发送数据
  232.   * @retval 无
  233.   */
  234. void  USART1_SendChar(u8 t)
  235. {
  236.     USART_SendData(USART1,t);
  237.     while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET);
  238.     while((USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET));//等待串口发送完毕
  239. }
  240.  /**
  241.   * @brief  USART1发送字符串
  242.   * @param  dat,发送数据
  243.   * @retval 无
  244.   */
  245. void USART1_SendString(void* buffer, uint16_t size)
  246. {
  247.     uint8_t i=0,*buf;
  248.     buf=buffer;
  249.      GPIO_SetBits(GPIOB,GPIO_Pin_5);  
  250.      while(size--)
  251.      {
  252.          USART1_SendChar(buf[i++]);
  253.      }
  254.      GPIO_ResetBits(GPIOB,GPIO_Pin_5);
  255. }
  258.  /**
  259.   * @brief  USART1加密发送字符串
  260.   * @param  dat,发送数据
  261.   * @retval 无
  262.   */
  263. void USART1_Encryption_SendString(void* buffer, uint16_t size)
  264. {
  265.     uint8_t i=0,*buf;
  266.     //encryption(buffer,size);
  267.     buf=buffer;
  268.      GPIO_SetBits(GPIOB,GPIO_Pin_5);  
  269.      while(size--)
  270.      {
  271.          USART1_SendChar(buf[i++]);
  272.      }
  273.      GPIO_ResetBits(GPIOB,GPIO_Pin_5);
  274. }

bsp_tim3.h

  1. #ifndef __BSP_TIM3_H
  2. #define __BSP_TIM3_H
  4. #include "stm32f10x.h"
  6. void TIM3_Int_Init(u16 arr,u16 psc);
  7. #endif // __BSP_TIM3_H

bsp_tim3.c

  1. #include "bsp_tim3.h"
  4. extern uint16_t time;
  7. //void TIM3_Int_Init(u16 arr,u16 psc)
  8. //{
  9. //  TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  10. //    NVIC_InitTypeDef NVIC_InitStructure;
  12. //    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); //时钟使能
  13. //    
  15. //    TIM_TimeBaseStructure.TIM_Period = arr; 
  16. //    TIM_TimeBaseStructure.TIM_Prescaler =psc; 
  17. //    TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1; 
  18. //    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  
  19. //    TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);
  20. // 
  21. //    TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE ); 
  24. //    NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;  
  25. //    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  
  26. //    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 5;  
  27. //    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; 
  28. //    NVIC_Init(&NVIC_InitStructure);  
  30. //    TIM_Cmd(TIM3, ENABLE);                    
  31. //}
  35. void TIM3_Int_Init(u16 arr,u16 psc)
  36. {
  37.     TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  38.     NVIC_InitTypeDef NVIC_InitStructure;
  40.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);         //时钟使能
  42.     //定时器TIM3初始化
  43.     TIM_TimeBaseStructure.TIM_Period = arr;                     //设置在下一个更新事件装入活动的自动重装载寄存器周期的值    
  44.     TIM_TimeBaseStructure.TIM_Prescaler =psc;                     //设置用来作为TIMx时钟频率除数的预分频值
  45.     TIM_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;     //设置时钟分割:TDTS = Tck_tim
  46.     TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up; //TIM向上计数模式
  47.     TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);             //根据指定的参数初始化TIMx的时间基数单位
  49.     TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE );                     //使能指定的TIM3中断,允许更新中断
  50.     TIM_ClearFlag(TIM3,TIM_IT_Update ); 
  52.     //中断优先级NVIC设置
  53.     NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;              //TIM3中断
  54.     NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;   //先占优先级0级
  55.     NVIC_InitStructure.NVIC_IRQChannelSubPriority = 5;          //从优先级3级
  56.     NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;             //IRQ通道被使能
  57.     NVIC_Init(&NVIC_InitStructure);                              //初始化NVIC寄存器
  59.     TIM_Cmd(TIM3, ENABLE);  //使能TIMx                     
  60. }
  63. //定时器3中断服务程序
  64. void TIM3_IRQHandler(void)   //TIM3中断
  65. {
  66.     static u16 mS_Cnt_0=0;
  67.     static u16 mS_Cnt_1=0;
  68.     static u16 mS_Cnt_2=0;
  69.     static u16 mS_Cnt_3=0;
  70.     static u16 mS_Cnt_4=0;
  71.     if(TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  //检查TIM3更新中断发生与否
  72.         //    if(TIM2->SR&0X0001)//寄存器操作
  73.     {
  74.         TIM_ClearITPendingBit(TIM3, TIM_IT_Update);      //清除TIMx更新中断标志 ,库函数操作
  75.         //---------------------------------------[2]
  77.         time++;
  79.         //---------------------------------------[5]
  80.     }
  81. }
  84. // 延迟分钟函数
  85. uint8_t delayed(uint8_t minute)
  86. {
  87.     // 1分钟的
  88.     if(time == 6000 * minute)
  89.     {
  90.         time = 0;
  91.         return 0;
  92.     }
  93. }
  97. //void TIM3_IRQHandler(void)   //TIM3中断
  98. //{
  99. //    static uint16_t Sys_Cnt[5]={0};
  100. //    if(TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  //检查TIM3更新中断发生与否
  101. //    {
  102. //        time++;
  103. //        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);      //清除TIMx更新中断标志 ,库函数操作 TIM_IT_Update
  104. //    }
  105. //}
  107. //void BASIC_TIM_IRQHandler(void)
  108. //{
  109. //    if ( TIM_GetITStatus( BASIC_TIM, TIM_IT_Update) != RESET ) 
  110. //    {    
  111. //        time++;
  112. //        TIM_ClearITPendingBit(BASIC_TIM , TIM_FLAG_Update);           
  113. //    }             
  114. //}

main.c

  1. /**********************
  2. 芯片：STM32F103C8T6
  4. 实现功能：
  6. 引脚：PC13
  7. ***********************/
  9. #include "stm32f10x.h"
  10. #include "bsp_DMAusart1.h"
  11. #include "bsp_tim3.h"
  13. uint16_t time=0;
  14. uint8_t time10 = 0;
  16. int main()
  17. {
  19.     USART1_Init(115200, OneUART.Tx_buf, OneUART.Rx_buf, USART1_REC_LEN);
  20.     USART1_DMASendString("time end!",sizeof("time end!"));
  22.     //每次进入中断服务程序间隔时间为((1+TIM_Prescaler )/72M)*(1+TIM_Period )=((1+7199)/72M)*(1+9999)=1秒
  23.     //TIM3_Int_Init(9999, 71); // 1ms 
  24.     //TIM3_Int_Init(59999, 71); // 60ms
  25.     //TIM3_Int_Init(59999, 7199); // 6s
  26.     //TIM3_Int_Init(59999, 35999); // 30s
  28.     while(1)
  29.     {
  32.         if(OneUART.Rx_end_flag)
  33.         {
  34.             if(OneUART.Rx_buf[0]== 0x01)
  35.             {
  36.                 OneUART.Rx_buf[0] = 0x00;
  37.                 TIM3_Int_Init(59999, 35999); // 30s
  39.             }
  41.             if(OneUART.Rx_buf[0]== 0x02)
  42.             {
  43.                 OneUART.Rx_buf[0] = 0x00;
  44.                 TIM_Cmd(TIM3, DISABLE); 
  45.             }
  46.         }
  49.         // 1分钟
  50.         if(time == 2)
  51.         {
  52.             time = 0;
  53.             // USART1_DMASendString("time end!",sizeof("time end!"));
  54.             USART1_DMASendString("1分钟!",sizeof("1分钟!"));
  55.             time10++;
  56.         }
  58.         // 10分钟
  59.         if(time10 == 10)
  60.         {
  61.             time10 = 0;
  62.             USART1_DMASendString("10分钟!", sizeof("10分钟!"));
  63.         }
  64.     }
  65. }

STM32_Project.zip