精华内容
参与话题
问答
  • stm32中断优先级概述

    2020-07-20 02:46:25
    STM32 目前支持的中断共为 84 个(16 个内核+68 个外部),可以提供16 级可编程中断优先级的设置,下面一起来学习一下
  • STM32中断优先级

    千次阅读 2012-11-26 15:05:44
    STM32中断优先级 本文博客链接:http://blog.csdn.net/jdh99,作者:jdh,转载请注明.   环境: 主机:XP 开发环境:MDK4.23 MCU:STM32F103CBT6 在Cortex-M3中定义了8个比特位用于设置...

    STM32中断优先级

    本文博客链接:http://blog.csdn.net/jdh99,作者:jdh,转载请注明.

     

    环境:

    主机:XP

    开发环境:MDK4.23

    MCU:STM32F103CBT6


    在Cortex-M3中定义了8个比特位用于设置中断源的优先级,而STM32用4位指定指定中断优先级

    STM32中优先级分组

    第0组:所有4位用于指定响应优先级
    第1组:最高1位用于指定抢占式优先级,最低3位用于指定响应优先级
    第2组:最高2位用于指定抢占式优先级,最低2位用于指定响应优先级
    第3组:最高3位用于指定抢占式优先级,最低1位用于指定响应优先级
    第4组:所有4位用于指定抢占式优先级


    示例代码:

        //配置UART1中断  
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_3);
        NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;               //通道设置为串口1中断  
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;       //中断占先等级0  
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;              //中断响应优先级0  
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                 //打开中断  
        NVIC_Init(&NVIC_InitStructure);

    中断优先级值越低,等级越高



    展开全文
  • STM32中断优先级详细讲解,还有简单的例子。综述,有限级判断,优先级分组等。
  • STM32(Cortex-M3)中有两个优先级的概念——抢占式优先级和响应优先级,有人把响应优先级称作'亚优先级'或'副优先级',每个中断源都需要被指定这两种优先级。 具有高抢占式优先级中断可以在具有低抢占式优先级的...
  • stm32中断优先级分组

    千次阅读 2016-12-27 08:29:06
    STM32中断优先级和开关总中断一,中断优先级:STM32(Cortex-M3)中的优先级概念 STM32(Cortex-M3)中有两个优先级的概念——抢占式优先级和响应优先级,有人把响应优先级称作'亚优先级'或'副优先级',每个中断源都需要...
    STM32中断优先级和开关总中断
    
    一,中断优先级:
    
    STM32(Cortex-M3)中的优先级概念
    STM32(Cortex-M3)中有两个优先级的概念——抢占式优先级和响应优先级,有人把响应优先级称作'亚优先级''副优先级',每个中断源都需要被指定这两种优先级。
    
    具有高抢占式优先级的中断可以在具有低抢占式优先级的中断处理过程中被响应,即中断嵌套,或者说高抢占式优先级的中断可以嵌套低抢占式优先级的中断。
    
    当两个中断源的抢占式优先级相同时,这两个中断将没有嵌套关系,当一个中断到来后,如果正在处理另一个中断,这个后到来的中断就要等到前一个中断处理完之后才能被处理。如果这两个中断同时到达,则中断控制器根据他们的响应优先级高低来决定先处理哪一个;如果他们的抢占式优先级和响应优先级都相等,则根据他们在中断表中的排位顺序决定先处理哪一个。
    
    既然每个中断源都需要被指定这两种优先级,就需要有相应的寄存器位记录每个中断的优先级;在Cortex-M3中定义了8个比特位用于设置中断源的优先级,这8个比特位可以有8种分配方式,如下:
    
    所有8位用于指定响应优先级
    最高1位用于指定抢占式优先级,最低7位用于指定响应优先级
    最高2位用于指定抢占式优先级,最低6位用于指定响应优先级
    最高3位用于指定抢占式优先级,最低5位用于指定响应优先级
    最高4位用于指定抢占式优先级,最低4位用于指定响应优先级
    最高5位用于指定抢占式优先级,最低3位用于指定响应优先级
    最高6位用于指定抢占式优先级,最低2位用于指定响应优先级
    最高7位用于指定抢占式优先级,最低1位用于指定响应优先级
    
    这就是优先级分组的概念。
    
    
    
    
    --------------------------------------------------------------------------------
    Cortex-M3允许具有较少中断源时使用较少的寄存器位指定中断源的优先级,因此STM32把指定中断优先级的寄存器位减少到4位,这4个寄存器位的分组方式如下: 
    
    第0组:所有4位用于指定响应优先级
    第1组:最高1位用于指定抢占式优先级,最低3位用于指定响应优先级
    第2组:最高2位用于指定抢占式优先级,最低2位用于指定响应优先级
    第3组:最高3位用于指定抢占式优先级,最低1位用于指定响应优先级
    第4组:所有4位用于指定抢占式优先级
    
    可以通过调用STM32的固件库中的函数NVIC_PriorityGroupConfig()选择使用哪种优先级分组方式,这个函数的参数有下列5种:
    
    NVIC_PriorityGroup_0 => 选择第0组
    NVIC_PriorityGroup_1 => 选择第1组
    NVIC_PriorityGroup_2 => 选择第2组
    NVIC_PriorityGroup_3 => 选择第3组
    NVIC_PriorityGroup_4 => 选择第4组 
    
    接下来就是指定中断源的优先级,下面以一个简单的例子说明如何指定中断源的抢占式优先级和响应优先级:
    
    // 选择使用优先级分组第1组
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    
    // 使能EXTI0中断
    NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQChannel;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; // 指定抢占式优先级别1
    
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 指定响应优先级别0
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    
    // 使能EXTI9_5中断
    NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQChannel;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; // 指定抢占式优先级别0
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; // 指定响应优先级别1
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    
    要注意的几点是:
    
    1)如果指定的抢占式优先级别或响应优先级别超出了选定的优先级分组所限定的范围,将可能得到意想不到的结果;
    
    2)抢占式优先级别相同的中断源之间没有嵌套关系;
    
    3)如果某个中断源被指定为某个抢占式优先级别,又没有其它中断源处于同一个抢占式优先级别,则可以为这个中断源指定任意有效的响应优先级别。
    
    二,开关总中断:
    
    在STM32/Cortex-M3中是通过改变CPU的当前优先级来允许或禁止中断。
    PRIMASK位:只允许NMI和hard fault异常,其他中断/异常都被屏蔽(当前CPU优先级=0)。
    FAULTMASK位:只允许NMI,其他所有中断/异常都被屏蔽(当前CPU优先级=-1)。
    
    在STM32固件库中(stm32f10x_nvic.c和stm32f10x_nvic.h) 定义了四个函数操作PRIMASK位和FAULTMASK位,改变CPU的当前优先级,从而达到控制所有中断的目的。
    
    下面两个函数等效于关闭总中断:
    void NVIC_SETPRIMASK(void);
    void NVIC_SETFAULTMASK(void);
    
    下面两个函数等效于开放总中断:
    void NVIC_RESETPRIMASK(void);
    void NVIC_RESETFAULTMASK(void);
    
    上面两组函数要成对使用,不能交叉使用。
    
    例如:
    
    第一种方法:
    NVIC_SETPRIMASK();   //关闭总中断
    NVIC_RESETPRIMASK();//开放总中断
    
    第二种方法:
    NVIC_SETFAULTMASK();   //关闭总中断
    NVIC_RESETFAULTMASK();//开放总中断
    
    常常使用
    
    NVIC_SETPRIMASK();                    // Disable Interrupts
    NVIC_RESETPRIMASK();                  // Enable Interrupts
    
    
    
    
    
    STM32时钟系统
    
    STM32资料   2009-09-23 14:53   阅读72   评论0   
    字号: 大大  中中  小小 
    在STM32中,有五个时钟源,为HSI、HSE、LSI、LSE、PLL。
    
    
    
    ①、HSI是高速内部时钟,RC振荡器,频率为8MHz。
    
    ②、HSE是高速外部时钟,可接石英/陶瓷谐振器,或者接外部时钟源,频率范围为4MHz~16MHz。
    
    ③、LSI是低速内部时钟,RC振荡器,频率为40kHz。
    
    ④、LSE是低速外部时钟,接频率为32.768kHz的石英晶体。
    
    ⑤、PLL为锁相环倍频输出,其时钟输入源可选择为HSI/2、HSE或者HSE/2。倍频可选择为2~16倍,但是其输出频率最大不得超过72MHz。
    
    
    
    
    
    图1 HSE/LSE时钟源
    
    其中40kHz的LSI供独立看门狗IWDG使用,另外它还可以被选择为实时时钟RTC的时钟源。另外,实时时钟RTC的时钟源还可以选择LSE,或者是HSE的128分频。RTC的时钟源通过RTCSEL[1:0]来选择。
    
    STM32中有一个全速功能的USB模块,其串行接口引擎需要一个频率为48MHz的时钟源。该时钟源只能从PLL输出端获取,可以选择为1.5分频或者1分频,也就是,当需要使用USB模块时,PLL必须使能,并且时钟频率配置为48MHz或72MHz。
    
    另外,STM32还可以选择一个时钟信号输出到MCO脚(PA8)上,可以选择为PLL输出的2分频、HSI、HSE、或者系统时钟。
    
    系统时钟SYSCLK,它是供STM32中绝大部分部件工作的时钟源。系统时钟可选择为PLL输出、HSI或者HSE。系统时钟最大频率为72MHz,它通过AHB分频器分频后送给各模块使用,AHB分频器可选择12481664128256512分频。其中AHB分频器输出的时钟送给5大模块使用:
    
    ①、送给AHB总线、内核、内存和DMA使用的HCLK时钟。
    
    ②、通过8分频后送给Cortex的系统定时器时钟。
    
    ③、直接送给Cortex的空闲运行时钟FCLK。
    
    ④、送给APB1分频器。APB1分频器可选择124816分频,其输出一路供APB1外设使用(PCLK1,最大频率36MHz),另一路送给定时器(Timer)234倍频器使用。该倍频器可选择1或者2倍频,时钟输出供定时器234使用。
    
    ⑤、送给APB2分频器。APB2分频器可选择124816分频,其输出一路供APB2外设使用(PCLK2,最大频率72MHz),另一路送给定时器(Timer)1倍频器使用。该倍频器可选择1或者2倍频,时钟输出供定时器1使用。另外,APB2分频器还有一路输出供ADC分频器使用,分频后送给ADC模块使用。ADC分频器可选择为2468分频。
    
    在以上的时钟输出中,有很多是带使能控制的,例如AHB总线时钟、内核时钟、各种APB1外设、APB2外设等等。当需要使用某模块时,记得一定要先使能对应的时钟。
    
    需要注意的是定时器的倍频器,当APB的分频为1时,它的倍频值为1,否则它的倍频值就为2。连接在APB1(低速外设)上的设备有:电源接口、备份接口、CAN、USB、I2C1、I2C2、UART2、UART3、SPI2、窗口看门狗、Timer2、Timer3、Timer4。注意USB模块虽然需要一个单独的48MHz时钟信号,但它应该不是供USB模块工作的时钟,而只是提供给串行接口引擎(SIE)使用的时钟。USB模块工作的时钟应该是由APB1提供的。连接在APB2(高速外设)上的设备有:UART1、SPI1、Timer1、ADC1、ADC2、所有普通IO口(PA~PE)、第二功能IO口。
    
    下图是STM32用户手册中的时钟系统结构图,通过该图可以从总体上掌握STM32的时钟系统。
    
    
    
    
    
    STM32外部中断之二
    
    STM32资料   2009-09-10 21:18   阅读243   评论0   
    字号: 大大  中中  小小 
    STM32 外部中断配置
    
    
    1配置中断
    
    1、 分配中断向量表:
    
    /* Set the Vector Table base location at 0x20000000 */ 
    
    NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
    
    2、 设置中断优先级:
    
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); //设置中断优先级
    
    3、 初始化外部中断:
    
    /*允许EXTI4中断 */
    
           NVIC_InitStructure.NVIC_IRQChannel = EXTI4_IRQChannel; //中断通道
    
           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = PreemptionPriorityValue;//强占优先级
    
           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; //次优先级
    
           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; //通道中断使能
    
           NVIC_Init(&NVIC_InitStructure);       //初始化中断
    
    注意:如果我们配置的外部针脚为PA4,或PB4,或PC4,PD4等,那么采用的外部中断也必须是EXTI4,同样,如果外部中断针脚是PA1,PB1,PC1,PD1 那么中断就要用EXTI1,其他类推。
    
    2配置GPIO针脚作为外部中断的触发事件 
    
    1、 选择IO针脚
    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    
    注意,如果的针脚是端口的4号针脚,配置的中断一定是EXTI4
    
    2、 配置针脚为输入
    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
    3、 初始化针脚
    
    GPIO_Init(GPIOD,&GPIO_InitStructure);
    
    
    3配置EXTI线,使中断线和IO针脚线连接上
    
    1、 将EXTI线连接到IO端口上
    
    将EXTI线4连接到端口GPIOD的第4个针脚上
    
           GPIO_EXTILineConfig(GPIO_PortSourceGPIOD,GPIO_PinSource4);
    
           注意:如果配置的针脚是4号,那么参数必须是GPIO_PinSource4
    
                  如果配置的针脚是3号,那么参数必须是GPIO_PinSource3
    
    2、配置中断边沿
    
           /*配置EXTI线0上出现下降沿,则产生中断*/
    
           EXTI_InitStructure.EXTI_Line = EXTI_Line4;
    
           注意:如果配置的4号针脚,那么EXTI_Line4是必须的
    
           EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    
           EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //下降沿触发
    
           EXTI_InitStructure.EXTI_LineCmd = ENABLE;     //中断线使能
    
           EXTI_Init(&EXTI_InitStructure);                 //初始化中断
    
           EXTI_GenerateSWInterrupt(EXTI_Line4);         //EXTI_Line4中断允许
    
    到此中断配置完成,可以写中断处理函数。
    
    举例:
    
    配置函数
    
    /*************************************************************************
    
    * 函数名      NVIC_Configration
    
    * 描述          配置各个中断寄存器
    
    * 输入           无 
    
    * 输出           无
    
    * 返回值       无
    
    ****************************************************************************/
    
    void NVIC_Configration(void)
    
    {
    
            NVIC_InitTypeDef NVIC_InitStructure; 
    
    //#ifdef VECT_TAB_RAM 
    
          /* Set the Vector Table base location at 0x20000000 */ 
    
          NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); 
    
    //#else /* VECT_TAB_FLASH */
    
          /* Set the Vector Table base location at 0x08000000 */ 
    
          //NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);   
    
    //#endif   
    
           NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); //设置中断优先级
    
           /*允许EXTI4中断 */
    
           NVIC_InitStructure.NVIC_IRQChannel = EXTI4_IRQChannel;
    
           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = PreemptionPriorityValue;
    
           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
           NVIC_Init(&NVIC_InitStructure);       
    
           /*允许EXTI9中断*/
    
           NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQChannel;
    
           NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
    
           NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    
           NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
           NVIC_Init(&NVIC_InitStructure);       
    
           /*配置SysTick处理优先级:优先级以及子优先级*/
    
    
    
    }
    
    /************************************************************************
    
    * 函数名       :GPIO_Configuration(void)
    
    * 描述           :配置TIM2阵脚
    
    * 输入           :无
    
    * 输出      :无
    
    * 返回           :无
    
    ************************************************************************/
    
    void GPIO_Configuration(void){
    
    /*    GPIO_InitTypeDef GPIO_InitStructure;
    
           GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;
    
           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
           GPIO_Init(GPIOA,&GPIO_InitStructure); */
    
           GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
    
           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    
           GPIO_Init(GPIOC,&GPIO_InitStructure);
    
           /*配置GPIOD的第一个管角为浮动输入*/
    
           GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    
           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
           GPIO_Init(GPIOD,&GPIO_InitStructure);
    
           /*配置GPIOB的第9个管脚为浮动输入*/
    
           GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
           GPIO_Init(GPIOB,&GPIO_InitStructure); 
    
    }
    
    
    /**************************************************************
    
    * 函数           SysTick_Configuration
    
    * 描述          设置SysTick
    
    * 输入           无
    
    * 输出          无
    
    * 返回值      无
    
    ***************************************************************/
    
    void SysTick_Configuration(void)
    
    {
    
          /*配置 HCLK 时钟做为SysTick 时钟源*/
    
           SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8); //系统时钟8分频 72MHz
    
           NVIC_SystemHandlerPriorityConfig(SystemHandler_SysTick, 8,2);
    
           /*SysTick Interrupt each 1000Hz with HCLK equal to 72MHz*/
    
           SysTick_SetReload(9000);//中断周期1ms
    
           /*Enable the SysTick Interrupt */
    
           SysTick_ITConfig(ENABLE);//打开中断           
    
           SysTick_CounterCmd(SysTick_Counter_Enable);
    
           SysTick_CounterCmd(SysTick_Counter_Clear);                 
    
    }
    
    
    /******************************************************************************
    
    * 函数名       EXTI_Configuration
    
    * 描述           配置EXTI线
    
    * 输入           无 
    
    * 输出           无
    
    * 返回值       无
    
    ******************************************************************************/
    
    void EXTI_Configuration(void){
    
           /*将EXTI线0连接到PA0*/
    
           GPIO_EXTILineConfig(GPIO_PortSourceGPIOD,GPIO_PinSource4);
    
           /*配置EXTI线0上出现下降沿,则产生中断*/
    
           EXTI_InitStructure.EXTI_Line = EXTI_Line4;
    
           EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    
           EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
    
           EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    
           EXTI_Init(&EXTI_InitStructure);
    
           EXTI_GenerateSWInterrupt(EXTI_Line4);
    
    
    
           /*将EXTI线9连接到PB9上*/
    
           GPIO_EXTILineConfig(GPIO_PortSourceGPIOB,GPIO_PinSource9);
    
           /*将EXTI线9上出现下降沿产生中断*/
    
           EXTI_InitStructure.EXTI_Line = EXTI_Line9;
    
           EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
    
           EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
    
           EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    
           EXTI_Init(&EXTI_InitStructure);
    
           EXTI_GenerateSWInterrupt(EXTI_Line9);        
    
    }
    
    中断函数:
    
    void EXTI4_IRQHandler(void)
    
    {
    
           if(EXTI_GetITStatus(EXTI_Line4)!= RESET){
    
                  EXTI_ClearITPendingBit(EXTI_Line4);
    
                  if(Ledflag == 0){
    
                         Ledflag = 1;
    
                         GPIOC->ODR |= 0X00000080;
    
                  }
    
                  else{
    
                         Ledflag = 0;           
    
                         GPIOC->ODR &= 0XFFFFFF7F;
    
                  }
    
           }
    
    }
    
    注:时钟设置的时候最好加上这句: 
    
    RCCRCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE); // 使能AFIO时钟
    
    
    
    
    
    STM32中定时器的时钟源
    
    STM32资料   2009-07-24 21:34   阅读277   评论0   
    字号: 大大  中中  小小 
    
    
    
    STM32中有多达8个定时器,其中TIM1和TIM8是能够产生三对PWM互补输出的高级定时器,常用于三相电机的驱动,它们的时钟由APB2的输出产生。其它6个为普通定时器,时钟由APB1的输出产生。
    
    下图是STM32参考手册上时钟分配图中,有关定时器时钟部分的截图:
    
    
    
    从图中可以看出,定时器的时钟不是直接来自APB1或APB2,而是来自于输入为APB1或APB2的一个倍频器,图中的蓝色部分。
    
    下面以定时器2~7的时钟说明这个倍频器的作用:当APB1的预分频系数为1时,这个倍频器不起作用,定时器的时钟频率等于APB1的频率;当APB1的预分频系数为其它数值(即预分频系数为24816)时,这个倍频器起作用,定时器的时钟频率等于APB1的频率两倍。
    
    假定AHB=36MHz,因为APB1允许的最大频率为36MHz,所以APB1的预分频系数可以取任意数值;当预分频系数=1时,APB1=36MHz,TIM2~7的时钟频率=36MHz(倍频器不起作用);当预分频系数=2时,APB1=18MHz,在倍频器的作用下,TIM2~7的时钟频率=36MHz。
    
    有人会问,既然需要TIM2~7的时钟频率=36MHz,为什么不直接取APB1的预分频系数=1?答案是:APB1不但要为TIM2~7提供时钟,而且还要为其它外设提供时钟;设置这个倍频器可以在保证其它外设使用较低时钟频率时,TIM2~7仍能得到较高的时钟频率。
    
    再举个例子:当AHB=72MHz时,APB1的预分频系数必须大于2,因为APB1的最大频率只能为36MHz。如果APB1的预分频系数=2,则因为这个倍频器,TIM2~7仍然能够得到72MHz的时钟频率。能够使用更高的时钟频率,无疑提高了定时器的分辨率,这也正是设计这个倍频器的初衷。
    
    STM32笔记之外部中断GPIO
    
    STM32资料   2009-07-14 13:35   阅读331   评论0   
    字号: 大大  中中  小小 
    b)        初始化函数定义:
    void EXTI_Configuration(void); //定义IO中断初始化函数
    c)        初始化函数调用:
    EXTI_Configuration();//IO中断初始化函数调用简单应用:
    d)        初始化函数:
    void EXTI_Configuration(void)
    {
      EXTI_InitTypeDef EXTI_InitStructure;        //EXTI初始化结构定义
    
    EXTI_ClearITPendingBit(EXTI_LINE_KEY_BUTTON);//清除中断标志
       GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource3);//管脚选择
       GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource4);
         GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource5);
         GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource6);
    
        EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;//事件选择
      EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;//触发模式
      EXTI_InitStructure.EXTI_Line = EXTI_Line3 | EXTI_Line4; //线路选择
      EXTI_InitStructure.EXTI_LineCmd = ENABLE;//启动中断
      EXTI_Init(&EXTI_InitStructure);//初始化
    }
    
    e)        RCC初始化函数中开启I/O时钟
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);
    
    GPIO初始化函数中定义输入I/O管脚。
    //IO输入,GPIOA的4脚输入
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;         //上拉输入
      GPIO_Init(GPIOA, &GPIO_InitStructure);                //初始化
    f)        在NVIC的初始化函数里面增加以下代码打开相关中断:
      NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQChannel;        //通道
      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;//占先级
      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                        //响应级
      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //启动
      NVIC_Init(&NVIC_InitStructure);                                                                //初始化
    
    g)        在stm32f10x_it.c文件中找到void USART1_IRQHandler函数,在其中添入执行代码。一般最少三个步骤:先使用if语句判断是发生那个中断,然后清除中断标志位,最后给字符串赋值,或做其他事情。
      if(EXTI_GetITStatus(EXTI_Line3) != RESET)                                  //判断中断发生来源
       { EXTI_ClearITPendingBit(EXTI_Line3);                                          //清除中断标志
        USART_SendData(USART1, 0x41);                                              //发送字符“a”
        GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)(1-GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_2)));//LED发生明暗交替
    }
    h)        中断注意事项:
    中断发生后必须清除中断位,否则会出现死循环不断发生这个中断。然后需要对中断类型进行判断再执行代码。
    使用EXTI的I/O中断,在完成RCC与GPIO硬件设置之后需要做三件事:初始化EXTI、NVIC开中断、编写中断执行代码。 
    
    STM32的USART
    
    STM32资料   2009-07-14 13:33   阅读489   评论4   
    字号: 大大  中中  小小 
    b)        初始化函数定义:
    void USART_Configuration(void);        //定义串口初始化函数
    c)        初始化函数调用:
    void UART_Configuration(void);        //串口初始化函数调用
    初始化代码:
    void USART_Configuration(void)                        //串口初始化函数
    {
    //串口参数初始化  
      USART_InitTypeDef USART_InitStructure;              //串口设置恢复默认参数
    
    //初始化参数设置
      USART_InitStructure.USART_BaudRate = 9600;                                     //波特率9600
       USART_InitStructure.USART_WordLength = USART_WordLength_8b;   //字长8位
      USART_InitStructure.USART_StopBits = USART_StopBits_1;                 //1位停止字节
      USART_InitStructure.USART_Parity = USART_Parity_No;                      //无奇偶校验
      USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无流控制
      USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//打开Rx接收和Tx发送功能
    
        USART_Init(USART1, &USART_InitStructure);                                         //初始化
      USART_Cmd(USART1, ENABLE);                                                          //启动串口
    }
    
    RCC中打开相应串口
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 , ENABLE);
    
    GPIO里面设定相应串口管脚模式
    //串口1的管脚初始化  
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;                        //管脚9
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;       //复用推挽输出
      GPIO_Init(GPIOA, &GPIO_InitStructure);                               //TX初始化
    
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                    //管脚10
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
      GPIO_Init(GPIOA, &GPIO_InitStructure);                             //RX初始化
    
    d)        简单应用:
    发送一位字符
    USART_SendData(USART1, 数据);                //发送一位数据
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){}                                                                                        //等待发送完毕
    接收一位字符
    while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET){}                                                                                        //等待接收完毕
    变量= (USART_ReceiveData(USART1));        //接受一个字节
    
    发送一个字符串
        先定义字符串:char rx_data[250];
          然后在需要发送的地方添加如下代码
      int i;                                                                     //定义循环变量
        while(rx_data!='\0')                                           //循环逐字输出,到结束字'\0'
        {USART_SendData(USART1, rx_data);            //发送字符
         while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){} //等待字符发送完毕
         i++;} 
    
    e)        USART注意事项:
    发动和接受都需要配合标志等待。
    只能对一个字节操作,对字符串等大量数据操作需要写函数
    
    使用串口所需设置:RCC初始化里面打开RCC_APB2PeriphClockCmd
    (RCC_APB2Periph_USARTx);GPIO里面管脚设定:串口RX(50Hz,IN_FLOATING);串口TX(50Hz,AF_PP); 
    
    f)        printf函数重定义(不必理解,调试通过以备后用)
    (1)        需要c标准函数:
    #include "stdio.h"2)        粘贴函数定义代码
    #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)  //定义为putchar应用3)        RCC中打开相应串口
    (4)        GPIO里面设定相应串口管脚模式
    (6)        增加为putchar函数。
    int putchar(int c)                                              //putchar函数
    {
      if (c == '\n'){putchar('\r');}                                //将printf的\n变成\r
      USART_SendData(USART1, c);                                    //发送字符
      while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){} //等待发送结束
      return c;                                                     //返回值
    }
    
    (8)        通过,试验成功。printf使用变量输出:%c字符,%d整数,%f浮点数,%s字符串,/n或/r为换行。注意:只能用于main.c中。
    
    3、        NVIC串口中断的应用
    a)        目的:利用前面调通的硬件基础,和几个函数的代码,进行串口的中断输入练习。因为在实际应用中,不使用中断进行的输入是效率非常低的,这种用法很少见,大部分串口的输入都离不开中断。
    b)        初始化函数定义及函数调用:不用添加和调用初始化函数,在指定调试地址的时候已经调用过,在那个NVIC_Configuration里面添加相应开中断代码就行了。
    c)        过程:
    i.        在串口初始化中USART_Cmd之前加入中断设置:
    USART_ITConfig(USART1, USART_IT_TXE, ENABLE);//TXE发送中断,TC传输完成中断,RXNE接收中断,PE奇偶错误中断,可以是多个。
    ii.        RCC、GPIO里面打开串口相应的基本时钟、管脚设置
    iii.        NVIC里面加入串口中断打开代码:
    NVIC_InitTypeDef NVIC_InitStructure;//中断默认参数
    
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQChannel;//通道设置为串口1中断
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;   //中断占先等级0
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;              //中断响应优先级0
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;             //打开中断
    NVIC_Init(&NVIC_InitStructure);                                                //初始化
    
    iv.        在stm32f10x_it.c文件中找到void USART1_IRQHandler函数,在其中添入执行代码。一般最少三个步骤:先使用if语句判断是发生那个中断,然后清除中断标志位,最后给字符串赋值,或做其他事情。
    void USART1_IRQHandler(void)                              //串口1中断
    {
    char RX_dat;                                                          //定义字符变量
    
      if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //判断发生接收中断
      {USART_ClearITPendingBit(USART1,  USART_IT_RXNE);          //清除中断标志
    
       GPIO_WriteBit(GPIOB, GPIO_Pin_10, (BitAction)0x01);             //开始传输
       RX_dat=USART_ReceiveData(USART1) & 0x7F;                       //接收数据,整理除去前两位
       USART_SendData(USART1, RX_dat);                                       //发送数据
       while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){}//等待发送结束
      }
    }
    
    d)        中断注意事项:
    可以随时在程序中使用USART_ITConfig(USART1, USART_IT_TXE, DISABLE);来关闭中断响应。
    NVIC_InitTypeDef NVIC_InitStructure定义一定要加在NVIC初始化模块的第一句。
    全局变量与函数的定义:在任意.c文件中定义的变量或函数,在其它.c文件中使用extern+定义代码再次定义就可以直接调用了。 
    
    STM32运行的必要硬件库
    
    STM32资料   2009-07-14 13:31   阅读163   评论0   
    字号: 大大  中中  小小 
    0、        实验之前的准备
    a)        接通串口转接器
    b)        下载IO与串口的原厂程序,编译通过保证调试所需硬件正常。
    
    1、        flash,lib,nvic,rcc和GPIO,基础程序库编写
    a)        这几个库函数中有一些函数是关于芯片的初始化的,每个程序中必用。为保障程序品质,初学阶段要求严格遵守官方习惯。注意,官方程序库例程中有个platform_config.h文件,是专门用来指定同类外设中第几号外设被使用,就是说在main.c里面所有外设序号用x代替,比如USARTx,程序会到这个头文件中去查找到底是用那些外设,初学的时候参考例程别被这个所迷惑住。
    b)        全部必用代码取自库函数所带例程,并增加逐句注释。
    c)        习惯顺序——Lib(debug),RCC(包括Flash优化),NVIC,GPIO
    d)        必用模块初始化函数的定义:
    void RCC_Configuration(void);        //定义时钟初始化函数
    void GPIO_Configuration(void);        //定义管脚初始化函数
    void NVIC_Configuration(void);        //定义中断管理初始化函数
    void Delay(vu32 nCount);                        //定义延迟函数
    e)        Main中的初始化函数调用:
    RCC_Configuration();                //时钟初始化函数调用
    NVIC_Configuration();        //中断初始化函数调用
    GPIO_Configuration();        //管脚初始化函数调用
    f)        Lib注意事项:
    属于Lib的Debug函数的调用,应该放在main函数最开始,不要改变其位置。
    
    g)        RCC注意事项:
    Flash优化处理可以不做,但是两句也不难也不用改参数……
    根据需要开启设备时钟可以节省电能
    时钟频率需要根据实际情况设置参数
    h)        NVIC注意事项
    注意理解占先优先级和响应优先级的分组的概念
    i)        GPIO注意事项
    注意以后的过程中收集不同管脚应用对应的频率和模式的设置。
    
    作为高低电平的I/O,所需设置:RCC初始化里面打开RCC_APB2
    PeriphClockCmd(RCC_APB2Periph_GPIOA);GPIO里面管脚设定:IO输出(50MHz,Out_PP);IO输入(50MHz,IPU);
    
    j)        GPIO应用
    GPIO_WriteBit(GPIOB, GPIO_Pin_2, Bit_RESET);//重置
    GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x01);//写入1
    GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x00);//写入0
    GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6) ;//读入IO
    k)        简单Delay函数
    void Delay(vu32 nCount)//简单延时函数
    {for(; nCount != 0; nCount--);} 
    
    基于STM32的PWM输出
    
    STM32资料   2009-07-14 13:30   阅读449   评论2   
    字号: 大大  中中  小小 
    c)        初始化函数定义:
    void TIM_Configuration(void);  //定义TIM初始化函数
    d)        初始化函数调用:
    TIM_Configuration();  //TIM初始化函数调用
    e)        初始化函数,不同于前面模块,TIM的初始化分为两部分——基本初始化和通道初始化:
    void TIM_Configuration(void)//TIM初始化函数
    { 
      TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;//定时器初始化结构
      TIM_OCInitTypeDef  TIM_OCInitStructure;//通道输出初始化结构
    
    //TIM3初始化
      TIM_TimeBaseStructure.TIM_Period = 0xFFFF;        //周期0~FFFF
      TIM_TimeBaseStructure.TIM_Prescaler = 5;          //时钟分频
      TIM_TimeBaseStructure.TIM_ClockDivision = 0;      //时钟分割
      TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;//模式
      TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);   //基本初始化
      TIM_ITConfig(TIM3, TIM_IT_CC4, ENABLE);//打开中断,中断需要这行代码
    
    //TIM3通道初始化
      TIM_OCStructInit(& TIM_OCInitStructure);                                                //默认参数
      TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;                    //工作状态
      TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;         //设定为输出,需要PWM输出才需要这行代码
      TIM_OCInitStructure.TIM_Pulse = 0x2000;                                 //占空长度
      TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;                 //高电平
      TIM_OC4Init(TIM3, &TIM_OCInitStructure);                                 //通道初始化
    
      TIM_Cmd(TIM3, ENABLE);                                                                        //启动TIM3
    }
    
    f)        RCC初始化函数中加入TIM时钟开启:
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM3, ENABLE);
    g)        GPIO里面将输入和输出管脚模式进行设置。信号:AF_PP,50MHz。
    h)        使用中断的话在NVIC里添加如下代码:
    
    //打开TIM2中断
      NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQChannel;  //通道
      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;//占先级
      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;           //响应级
      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;         //启动
      NVIC_Init(&NVIC_InitStructure);                                            //初始化
    
    中断代码:
    void TIM2_IRQHandler(void)
    {
      if (TIM_GetITStatus(TIM2, TIM_IT_CC4) != RESET)       //判断中断来源
      {
        TIM_ClearITPendingBit(TIM2, TIM_IT_CC4);            //清除中断标志
        GPIO_WriteBit(GPIOB, GPIO_Pin_11, (BitAction)(1-GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_11)));//变换LED色彩
        IC4value = TIM_GetCapture4(TIM2);                   //获取捕捉数值
      }  
    }
    
    i)        简单应用:
    //改变占空比
    TIM_SetCompare4(TIM3, 变量);
    
    j)        注意事项:
    管脚的IO输出模式是根据应用来定,比如如果用PWM输出驱动LED则应该将相应管脚设为AF_PP,否则单片机没有输出。 
    
    STM32资料一(转载)
    
    STM32资料   2009-06-14 20:15   阅读766   评论1   
    字号: 大大  中中  小小 
    
    
    注:下面是一些常用的代码,网上很多但是大多注释不全。高手看没问题,对于我们这些新手就费劲了……所以我把这些代码集中,进行了逐句注释,希望对新手们有价值。
    
     阅读flash: 芯片内部存储器flash操作函数
    
    我的理解——对芯片内部flash进行操作的函数,包括读取,状态,擦除,写入等等,可以允许程序去操作flash上的数据。
    
    基础应用1,FLASH时序延迟几个周期,等待总线同步操作。推荐按照单片机系统运行频率,024MHz时,取Latency=02448MHz时,取Latency=148~72MHz时,取Latency=2。所有程序中必须的
    
    用法:FLASH_SetLatency(FLASH_Latency_2);
    
    位置:RCC初始化子函数里面,时钟起振之后。
    
    基础应用2,开启FLASH预读缓冲功能,加速FLASH的读取。所有程序中必须的
    
    用法:FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
    
    位置:RCC初始化子函数里面,时钟起振之后。
    
    3、        阅读lib:调试所有外设初始化的函数。
    
    我的理解——不理解,也不需要理解。只要知道所有外设在调试的时候,EWRAM需要从这个函数里面获得调试所需信息的地址或者指针之类的信息。
    
    基础应用1,只有一个函数debug。所有程序中必须的。
    
    用法:        #ifdef DEBUG
    
                      debug();
    
    #endif
    
            位置:main函数开头,声明变量之后。
    
    4、        阅读nvic:系统中断管理。
    
    我的理解——管理系统内部的中断,负责打开和关闭中断。
    
    基础应用1,中断的初始化函数,包括设置中断向量表位置,和开启所需的中断两部分。所有程序中必须的。
    
    用法:        void NVIC_Configuration(void)
    
    {
    
    NVIC_InitTypeDef NVIC_InitStructure;                     //中断管理恢复默认参数
    
    #ifdef  VECT_TAB_RAM   //如果C/C++ Compiler\Preprocessor\Defined symbols中的定义了VECT_TAB_RAM(见程序库更改内容的表格)
    
    NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); //则在RAM调试
    
    #else                                                                      //如果没有定义VECT_TAB_RAM
    
    NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);//则在Flash里调试
    
    #endif                                                                      //结束判断语句
    
    //以下为中断的开启过程,不是所有程序必须的。
    
    //NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); 
    
    //设置NVIC优先级分组,方式。
    
    //注:一共16个优先级,分为抢占式和响应式。两种优先级所占的数量由此代码确定,NVIC_PriorityGroup_x可以是0、1、2、3、4,分别代表抢占优先级有1、2、4、8、16个和响应优先级有16、8、4、2、1个。规定两种优先级的数量后,所有的中断级别必须在其中选择,抢占级别高的会打断其他中断优先执行,而响应级别高的会在其他中断执行完优先执行。
    
    //NVIC_InitStructure.NVIC_IRQChannel = 中断通道名;  //开中断,中断名称见函数库
    
    //NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //抢占优先级
    
    //NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;         //响应优先级
    
    //NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;    //启动此通道的中断
    
    //NVIC_Init(&NVIC_InitStructure);                                        //中断初始化
    
    }
    
    5、        阅读rcc:单片机时钟管理。
    
    我的理解——管理外部、内部和外设的时钟,设置、打开和关闭这些时钟。
    
    基础应用1:时钟的初始化函数过程——
    
    用法:void RCC_Configuration(void)                                //时钟初始化函数
    
    {
    
      ErrorStatus HSEStartUpStatus;                                        //等待时钟的稳定
    
      RCC_DeInit();                                                                   //时钟管理重置
    
      RCC_HSEConfig(RCC_HSE_ON);                                    //打开外部晶振
    
      HSEStartUpStatus = RCC_WaitForHSEStartUp();             //等待外部晶振就绪
    
    if (HSEStartUpStatus == SUCCESS)
    
      {
    
    FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable);
    
    //flash读取缓冲,加速
    
        FLASH_SetLatency(FLASH_Latency_2);                        //flash操作的延时
    
    RCC_HCLKConfig(RCC_SYSCLK_Div1);                       //AHB使用系统时钟
    
        RCC_PCLK2Config(RCC_HCLK_Div2);                          //APB2(高速)为HCLK的一半
    
        RCC_PCLK1Config(RCC_HCLK_Div2);                          //APB1(低速)为HCLK的一半
    
    //注:AHB主要负责外部存储器时钟。PB2负责AD,I/O,高级TIM,串口1。APB1负责DA,USB,SPI,I2C,CAN,串口2345,普通TIM。
    
        RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9);  //PLLCLK = 8MHz * 9 = 72 MH
    
        RCC_PLLCmd(ENABLE);                                                //启动PLL
    
    while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET){}    //等待PLL启动
    
    RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK);  //将PLL设置为系统时钟源
    
     while (RCC_GetSYSCLKSource() != 0x08){}    //等待系统时钟源的启动
    
      }
    
    //RCC_AHBPeriphClockCmd(ABP2设备1 | ABP2设备2 |, ENABLE); //启动AHP设备
    
    //RCC_APB2PeriphClockCmd(ABP2设备1 | ABP2设备2 |, ENABLE);//启动ABP2设备
    
      //RCC_APB1PeriphClockCmd(ABP2设备1 | ABP2设备2 |, ENABLE); //启动ABP1设备
    
    }
    
    6、        阅读exti:外部设备中断函数
    
    我的理解——外部设备通过引脚给出的硬件中断,也可以产生软件中断,19个上升、下降或都触发。EXTI0~EXTI15连接到管脚,EXTI线16连接到PVD(VDD监视),EXTI线17连接到RTC(闹钟),EXTI线18连接到USB(唤醒)。
    
     基础应用1,设定外部中断初始化函数。按需求,不是必须代码。
    
            用法: void EXTI_Configuration(void)
    
    {
    
    EXTI_InitTypeDef EXTI_InitStructure;                                  //外部设备中断恢复默认参数
    
    EXTI_InitStructure.EXTI_Line = 通道1|通道2;  //设定所需产生外部中断的通道,一共19个。
    
    EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;     //产生中断
    
    EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling; //上升下降沿都触发 
    
    EXTI_InitStructure.EXTI_LineCmd = ENABLE;                   //启动中断的接收 
    
    EXTI_Init(&EXTI_InitStructure);                           //外部设备中断启动
    
    }
    
            7、        阅读dma:通过总线而越过CPU读取外设数据
    
    我的理解——通过DMA应用可以加速单片机外设、存储器之间的数据传输,并在传输期间不影响CPU进行其他事情。这对于入门开发基本功能来说没有太大必要,这个内容先行跳过。
    
    8、        阅读systic:系统定时器
    
    我的理解——可以输出和利用系统时钟的计数、状态。
    
    基础应用1,精确计时的延时子函数。推荐使用的代码。
    
            用法:
    
    static vu32 TimingDelay;                                                                                 //全局变量声明
    
    void SysTick_Config(void)                                                                               //systick初始化函数
    
    {
    
        SysTick_CounterCmd(SysTick_Counter_Disable);                                     //停止系统定时器
    
        SysTick_ITConfig(DISABLE);                                //停止systick中断
    
              SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8); //systick使用HCLK作为时钟源,频率值除以8。
    
        SysTick_SetReload(9000);                                                                       //重置时间1毫秒(以72MHz为基础计算)
    
        SysTick_ITConfig(ENABLE);                                                                     //开启systic中断
    
    }
    
    void Delay (u32 nTime)                                                                                   //延迟一毫秒的函数
    
    {
    
        SysTick_CounterCmd(SysTick_Counter_Enable);                            //systic开始计时
    
       TimingDelay = nTime;                                            //计时长度赋值给递减变量
    
        while(TimingDelay != 0);                                //检测是否计时完成
    
        SysTick_CounterCmd(SysTick_Counter_Disable);                                             //关闭计数器
    
        SysTick_CounterCmd(SysTick_Counter_Clear);                            //清除计数值
    
    }
    
    void TimingDelay_Decrement(void)  //递减变量函数,函数名由“stm32f10x_it.c”中的中断响应函数定义好了。
    
    {
    
        if (TimingDelay != 0x00)                                //检测计数变量是否达到0
    
                { TimingDelay--;                                //计数变量递减
    
                }
    
    }
    
    注:建议熟练后使用,所涉及知识和设备太多,新手出错的可能性比较大。新手可用简化的延时函数代替:
    
    void Delay(vu32 nCount)                                                                                 //简单延时函数
    
    {
    
      for(; nCount != 0; nCount--);                                                                          //循环变量递减计数
    
    }
    
    当延时较长,又不需要精确计时的时候可以使用嵌套循环:
    
    void Delay(vu32 nCount)                                             //简单的长时间延时函数
    
    {int i;                                                //声明内部递减变量
    
      for(; nCount != 0; nCount--)                                                                    //递减变量计数
    
    {for (i=0; i<0xffff; i++)}                                                                                        //内部循环递减变量计数
    
    }
    
    9、        阅读gpio:I/O设置函数
    
    我的理解——所有输入输出管脚模式设置,可以是上下拉、浮空、开漏、模拟、推挽模式,频率特性为2M,10M,50M。也可以向该管脚直接写入数据和读取数据。
    
            基础应用1,gpio初始化函数。所有程序必须。
    
            用法:void GPIO_Configuration(void)
    
    {
    
    GPIO_InitTypeDef GPIO_InitStructure;                            //GPIO状态恢复默认参数
    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_标号 | GPIO_Pin_标号 ;  //管脚位置定义,标号可以是NONE、ALL、0至15。
    
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;//输出速度2MHz
    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AIN;        //模拟输入模式
    
    GPIO_Init(GPIOC, &GPIO_InitStructure);                //C组GPIO初始化
    
    //注:以上四行代码为一组,每组GPIO属性必须相同,默认的GPIO参数为:ALL,2MHz,FLATING。如果其中任意一行与前一组相应设置相同,那么那一行可以省略,由此推论如果前面已经将此行参数设定为默认参数(包括使用GPIO_InitTypeDef GPIO_InitStructure代码),本组应用也是默认参数的话,那么也可以省略。以下重复这个过程直到所有应用的管脚全部被定义完毕。
    
    ……
    
    }
    
     基础应用2,向管脚写入01
    
            用法:GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x01);      //写入1
    
    基础应用3,从管脚读入01
    
            用法:GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6)
    
    STM32笔记之七:让它跑起来,基本硬件功能的建立
    
    0、        实验之前的准备
    
    a)        接通串口转接器
    
    b)        下载IO与串口的原厂程序,编译通过保证调试所需硬件正常。
    
    1、        flash,lib,nvic,rcc和GPIO,基础程序库编写
    
    a)        这几个库函数中有一些函数是关于芯片的初始化的,每个程序中必用。为保障程序品质,初学阶段要求严格遵守官方习惯。注意,官方程序库例程中有个platform_config.h文件,是专门用来指定同类外设中第几号外设被使用,就是说在main.c里面所有外设序号用x代替,比如USARTx,程序会到这个头文件中去查找到底是用那些外设,初学的时候参考例程别被这个所迷惑住。
    
    b)        全部必用代码取自库函数所带例程,并增加逐句注释。
    
    c)        习惯顺序——Lib(debug),RCC(包括Flash优化),NVIC,GPIO
    
    d)        必用模块初始化函数的定义:
    
    void RCC_Configuration(void);        //定义时钟初始化函数
    
    void GPIO_Configuration(void);        //定义管脚初始化函数
    
    void NVIC_Configuration(void);        //定义中断管理初始化函数
    
    void Delay(vu32 nCount);                        //定义延迟函数
    
    e)        Main中的初始化函数调用:
    
    RCC_Configuration();                //时钟初始化函数调用
    
    NVIC_Configuration();        //中断初始化函数调用
    
    GPIO_Configuration();        //管脚初始化函数调用
    
    f)        Lib注意事项:
    
    属于Lib的Debug函数的调用,应该放在main函数最开始,不要改变其位置。
    
    g)        RCC注意事项:
    
    Flash优化处理可以不做,但是两句也不难也不用改参数……
    
    根据需要开启设备时钟可以节省电能
    
    时钟频率需要根据实际情况设置参数
    
    h)        NVIC注意事项
    
    注意理解占先优先级和响应优先级的分组的概念
    
    i)        GPIO注意事项
    
    注意以后的过程中收集不同管脚应用对应的频率和模式的设置。
    
    作为高低电平的I/O,所需设置:RCC初始化里面打开RCC_APB2
    
    PeriphClockCmd(RCC_APB2Periph_GPIOA);GPIO里面管脚设定:IO输出(50MHz,Out_PP);IO输入(50MHz,IPU);
    
    j)        GPIO应用
    
    GPIO_WriteBit(GPIOB, GPIO_Pin_2, Bit_RESET);//重置
    
    GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x01);//写入1
    
    GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x00);//写入0
    
    GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6) ;//读入IO
    
    k)        简单Delay函数
    
    void Delay(vu32 nCount)//简单延时函数
    
    {for(; nCount != 0; nCount--);}
    
    实验步骤:
    
    RCC初始化函数里添加:RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB , ENABLE);
    
    不用其他中断,NVIC初始化函数不用改
    
    GPIO初始化代码:
    
    //IO输入,GPIOB的2、10、11脚输出
    
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2 ;//管脚号
    
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   //输出速度
    
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    //输入输出模式
    
         GPIO_Init(GPIOB, &GPIO_InitStructure);              //初始化
    
    简单的延迟函数:
    
    void Delay(vu32 nCount)                     //简单延时函数
    
    { for (; nCount != 0; nCount--);}           //循环计数延时
    
    完成之后再在main.c的while里面写一段:
    
    GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x01);//写入1
    
    Delay(0xffff);
    
    GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)0x00);//写入0
    
    Delay(0xffff);
    
    就可以看到连接在PB2脚上的LED闪烁了,单片机就跑起来了。
    
    STM32笔记之八:来跟PC打个招呼,基本串口通讯
    
    a)        目的:在基础实验成功的基础上,对串口的调试方法进行实践。硬件代码顺利完成之后,对日后调试需要用到的printf重定义进行调试,固定在自己的库函数中。
    
    b)        初始化函数定义:
    
    void USART_Configuration(void);        //定义串口初始化函数
    
    c)        初始化函数调用:
    
    void UART_Configuration(void);        //串口初始化函数调用
    
    初始化代码:
    
    void USART_Configuration(void)                        //串口初始化函数
    
    {
    
    //串口参数初始化  
    
      USART_InitTypeDef USART_InitStructure;              //串口设置恢复默认参数
    
    //初始化参数设置
    
      USART_InitStructure.USART_BaudRate = 9600;                                     //波特率9600
    
       USART_InitStructure.USART_WordLength = USART_WordLength_8b;   //字长8位
    
      USART_InitStructure.USART_StopBits = USART_StopBits_1;                 //1位停止字节
    
      USART_InitStructure.USART_Parity = USART_Parity_No;                      //无奇偶校验
    
      USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无流控制
    
      USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;//打开Rx接收和Tx发送功能
    
     USART_Init(USART1, &USART_InitStructure);                                         //初始化
    
      USART_Cmd(USART1, ENABLE);                                                          //启动串口
    
    }
    
    RCC中打开相应串口
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 , ENABLE);
    
    GPIO里面设定相应串口管脚模式
    
    //串口1的管脚初始化  
    
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;                        //管脚9
    
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;       //复用推挽输出
    
      GPIO_Init(GPIOA, &GPIO_InitStructure);                               //TX初始化
    
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;                    //管脚10
    
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; //浮空输入
    
      GPIO_Init(GPIOA, &GPIO_InitStructure);                             //RX初始化
    
    d)        简单应用:
    
    发送一位字符
    
    USART_SendData(USART1, 数据);                //发送一位数据
    
    while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){}                                                                                        //等待发送完毕
    
    接收一位字符
    
    while(USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET){}                                                                                        //等待接收完毕
    
    变量= (USART_ReceiveData(USART1));        //接受一个字节
    
    发送一个字符串
    
        先定义字符串:char rx_data[250];
    
          然后在需要发送的地方添加如下代码
    
      int i;                                                                     //定义循环变量
    
        while(rx_data!='\0')                                           //循环逐字输出,到结束字'\0'
    
        {USART_SendData(USART1, rx_data);            //发送字符
    
         while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){} //等待字符发送完毕
    
         i++;} 
    
    e)        USART注意事项:
    
    发动和接受都需要配合标志等待。
    
    只能对一个字节操作,对字符串等大量数据操作需要写函数
    
    使用串口所需设置:RCC初始化里面打开RCC_APB2PeriphClockCmd
    
    (RCC_APB2Periph_USARTx);GPIO里面管脚设定:串口RX(50Hz,IN_FLOATING);串口TX(50Hz,AF_PP); 
    
    f)        printf函数重定义(不必理解,调试通过以备后用)
    
    (1)        需要c标准函数:
    
    #include "stdio.h"2)        粘贴函数定义代码
    
    #define PUTCHAR_PROTOTYPE int __io_putchar(int ch)  //定义为putchar应用3)        RCC中打开相应串口
    
    (4)        GPIO里面设定相应串口管脚模式
    
    (6)        增加为putchar函数。
    
    int putchar(int c)                                              //putchar函数
    
    {
    
      if (c == '\n'){putchar('\r');}                                //将printf的\n变成\r
    
      USART_SendData(USART1, c);                                    //发送字符
    
      while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){} //等待发送结束
    
      return c;                                                     //返回值
    
    }
    
    (8)        通过,试验成功。printf使用变量输出:%c字符,%d整数,%f浮点数,%s字符串,/n或/r为换行。注意:只能用于main.c中。
    
    3、        NVIC串口中断的应用
    
    a)        目的:利用前面调通的硬件基础,和几个函数的代码,进行串口的中断输入练习。因为在实际应用中,不使用中断进行的输入是效率非常低的,这种用法很少见,大部分串口的输入都离不开中断。
    
    b)        初始化函数定义及函数调用:不用添加和调用初始化函数,在指定调试地址的时候已经调用过,在那个NVIC_Configuration里面添加相应开中断代码就行了。
    
    c)        过程:
    
    i.        在串口初始化中USART_Cmd之前加入中断设置:
    
    USART_ITConfig(USART1, USART_IT_TXE, ENABLE);//TXE发送中断,TC传输完成中断,RXNE接收中断,PE奇偶错误中断,可以是多个。
    
    ii.        RCC、GPIO里面打开串口相应的基本时钟、管脚设置
    
    iii.        NVIC里面加入串口中断打开代码:
    
    NVIC_InitTypeDef NVIC_InitStructure;//中断默认参数
    
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQChannel;//通道设置为串口1中断
    
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;   //中断占先等级0
    
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;              //中断响应优先级0
    
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;             //打开中断
    
    NVIC_Init(&NVIC_InitStructure);                                                //初始化
    
    iv.        在stm32f10x_it.c文件中找到void USART1_IRQHandler函数,在其中添入执行代码。一般最少三个步骤:先使用if语句判断是发生那个中断,然后清除中断标志位,最后给字符串赋值,或做其他事情。
    
    void USART1_IRQHandler(void)                              //串口1中断
    
    {
    
    char RX_dat;                                                          //定义字符变量
    
        if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //判断发生接收中断
    
      {USART_ClearITPendingBit(USART1,  USART_IT_RXNE);          //清除中断标志
    
       GPIO_WriteBit(GPIOB, GPIO_Pin_10, (BitAction)0x01);             //开始传输
    
       RX_dat=USART_ReceiveData(USART1) & 0x7F;                       //接收数据,整理除去前两位
    
       USART_SendData(USART1, RX_dat);                                       //发送数据
    
       while(USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET){}//等待发送结束
    
      }
    
    }
    
    d)        中断注意事项:
    
    可以随时在程序中使用USART_ITConfig(USART1, USART_IT_TXE, DISABLE);来关闭中断响应。
    
    NVIC_InitTypeDef NVIC_InitStructure定义一定要加在NVIC初始化模块的第一句。
    
    全局变量与函数的定义:在任意.c文件中定义的变量或函数,在其它.c文件中使用extern+定义代码再次定义就可以直接调用了。
    
    STM32笔记之九:打断它来为我办事,EXIT (外部I/O中断)应用
    
    a)        目的:跟串口输入类似,不使用中断进行的IO输入效率也很低,而且可以通过EXTI插入按钮事件,本节联系EXTI中断。
    
    b)        初始化函数定义:
    
    void EXTI_Configuration(void); //定义IO中断初始化函数
    
    c)        初始化函数调用:
    
    EXTI_Configuration();//IO中断初始化函数调用简单应用:
    
    d)        初始化函数:
    
    void EXTI_Configuration(void)
    
    { EXTI_InitTypeDef EXTI_InitStructure;        //EXTI初始化结构定义
    
    EXTI_ClearITPendingBit(EXTI_LINE_KEY_BUTTON);//清除中断标志
    
       GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource3);//管脚选择
    
       GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource4);
    
         GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource5);
    
         GPIO_EXTILineConfig(GPIO_PortSourceGPIOA, GPIO_PinSource6);
    
     EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;//事件选择
    
      EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;//触发模式
    
      EXTI_InitStructure.EXTI_Line = EXTI_Line3 | EXTI_Line4; //线路选择
    
      EXTI_InitStructure.EXTI_LineCmd = ENABLE;//启动中断
    
      EXTI_Init(&EXTI_InitStructure);//初始化
    
    }
    
    e)        RCC初始化函数中开启I/O时钟
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE);
    
    GPIO初始化函数中定义输入I/O管脚。
    
    //IO输入,GPIOA的4脚输入
    
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;         //上拉输入
    
      GPIO_Init(GPIOA, &GPIO_InitStructure);                //初始化
    
    f)        在NVIC的初始化函数里面增加以下代码打开相关中断:
    
      NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQChannel;        //通道
    
      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;//占先级
    
      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;                        //响应级
    
      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //启动
    
      NVIC_Init(&NVIC_InitStructure);                                                                //初始化
    
    g)        在stm32f10x_it.c文件中找到void USART1_IRQHandler函数,在其中添入执行代码。一般最少三个步骤:先使用if语句判断是发生那个中断,然后清除中断标志位,最后给字符串赋值,或做其他事情。
    
      if(EXTI_GetITStatus(EXTI_Line3) != RESET)                                  //判断中断发生来源
    
       { EXTI_ClearITPendingBit(EXTI_Line3);                                          //清除中断标志
    
        USART_SendData(USART1, 0x41);                                              //发送字符“a”
    
        GPIO_WriteBit(GPIOB, GPIO_Pin_2, (BitAction)(1-GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_2)));//LED发生明暗交替
    
    }
    
    h)        中断注意事项:
    
    中断发生后必须清除中断位,否则会出现死循环不断发生这个中断。然后需要对中断类型进行判断再执行代码。
    
    使用EXTI的I/O中断,在完成RCC与GPIO硬件设置之后需要做三件事:初始化EXTI、NVIC开中断、编写中断执行代码。
    
    STM32笔记之十:工作工作,PWM输出
    
    a)        目的:基础PWM输出,以及中断配合应用。输出选用PB1,配置为TIM3_CH4,是目标板的LED6控制脚。
    
    b)        对于简单的PWM输出应用,暂时无需考虑TIM1的高级功能之区别。
    
    c)        初始化函数定义:
    
    void TIM_Configuration(void);  //定义TIM初始化函数
    
    d)        初始化函数调用:
    
    TIM_Configuration();  //TIM初始化函数调用
    
    e)        初始化函数,不同于前面模块,TIM的初始化分为两部分——基本初始化和通道初始化:
    
    void TIM_Configuration(void)//TIM初始化函数
    
    { 
    
      TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;//定时器初始化结构
    
      TIM_OCInitTypeDef  TIM_OCInitStructure;//通道输出初始化结构
    
    //TIM3初始化
    
      TIM_TimeBaseStructure.TIM_Period = 0xFFFF;        //周期0~FFFF
    
      TIM_TimeBaseStructure.TIM_Prescaler = 5;          //时钟分频
    
      TIM_TimeBaseStructure.TIM_ClockDivision = 0;      //时钟分割
    
      TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;//模式
    
      TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);   //基本初始化
    
      TIM_ITConfig(TIM3, TIM_IT_CC4, ENABLE);//打开中断,中断需要这行代码
    
      //TIM3通道初始化
    
      TIM_OCStructInit(& TIM_OCInitStructure);                                                //默认参数
    
      TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;                    //工作状态
    
      TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;         //设定为输出,需要PWM输出才需要这行代码
    
      TIM_OCInitStructure.TIM_Pulse = 0x2000;                                 //占空长度
    
      TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;                 //高电平
    
      TIM_OC4Init(TIM3, &TIM_OCInitStructure);                                 //通道初始化
    
     TIM_Cmd(TIM3, ENABLE);                                                                        //启动TIM3
    
    }
    
    f)        RCC初始化函数中加入TIM时钟开启:
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM3, ENABLE);
    
    g)        GPIO里面将输入和输出管脚模式进行设置。信号:AF_PP,50MHz。
    
    h)        使用中断的话在NVIC里添加如下代码:
    
    //打开TIM2中断
    
      NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQChannel;  //通道
    
      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3;//占先级
    
      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;           //响应级
    
      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;         //启动
    
      NVIC_Init(&NVIC_InitStructure);                                            //初始化
    
    中断代码:
    
    void TIM2_IRQHandler(void)
    
    {
    
      if (TIM_GetITStatus(TIM2, TIM_IT_CC4) != RESET)       //判断中断来源
    
      {
    
        TIM_ClearITPendingBit(TIM2, TIM_IT_CC4);            //清除中断标志
    
        GPIO_WriteBit(GPIOB, GPIO_Pin_11, (BitAction)(1-GPIO_ReadOutputDataBit(GPIOB, GPIO_Pin_11)));//变换LED色彩
    
        IC4value = TIM_GetCapture4(TIM2);                   //获取捕捉数值
    
      }  
    
    }
    
    i)        简单应用:
    
    //改变占空比
    
    TIM_SetCompare4(TIM3, 变量);
    
    j)        注意事项:
    
    管脚的IO输出模式是根据应用来定,比如如果用PWM输出驱动LED则应该将相应管脚设为AF_PP,否则单片机没有输出
    
    我的测试程序可以发出不断循环三种波长并捕获,对比结果如下:
    
    捕捉的稳定性很好,也就是说,同样的方波捕捉到数值相差在一两个数值。
    
    捕捉的精度跟你设置的滤波器长度有关,在这里
    
    TIM_ICInitStructure.TIM_ICFilter = 0x4;        //滤波设置,经历几个周期跳变认定波形稳定0x0~0xF
    
    这个越长就会捕捉数值越小,但是偏差几十个数值,下面是0416个周期滤波的比较,out是输出的数值,in是捕捉到的。
    
    现在有两个疑问:
    
    1、在TIM2的捕捉输入通道初始化里面这句
    
    TIM_SelectInputTrigger(TIM2, TIM_TS_TI2FP2);   //选择时钟触发源
    
    按照硬件框图,4通道应该对应TI4FP4。可是实际使用TI1FP1,TI2FP2都行,其他均编译错误未注册。这是为什么?
    
    2、关闭调试器和IAR程序,直接供电跑出来的结果第一个周期很正常,当输出脉宽第二次循环变小后捕捉的数值就差的远了。不知道是为什么
    
    STM32笔记之十二:时钟不息工作不止,systic时钟应用
    
    a)        目的:使用系统时钟来进行两项实验——周期执行代码与精确定时延迟。
    
    b)        初始化函数定义:
    
    void SysTick_Configuration(void);
    
    c)        初始化函数调用:
    
    SysTick_Configuration();
    
    d)        初始化函数:
    
    void SysTick_Configuration(void)
    
    {
    
      SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);//时钟除8
    
      SysTick_SetReload(250000);                                                    //计数周期长度
    
      SysTick_CounterCmd(SysTick_Counter_Enable);                   //启动计时器
    
      SysTick_ITConfig(ENABLE);                                                     //打开中断
    
    }
    
    e)        在NVIC的初始化函数里面增加以下代码打开相关中断:
    
    NVIC_SystemHandlerPriorityConfig(SystemHandler_SysTick, 1, 0);//中断等级设置,一般设置的高一些会少受其他影响
    
    f)        在stm32f10x_it.c文件中找到void SysTickHandler 函数
    
    void SysTickHandler(void)
    
    {
    
    执行代码
    
    }
    
    g)        简单应用:精确延迟函数,因为systic中断往往被用来执行周期循环代码,所以一些例程中使用其中断的启动和禁止来编写的精确延时函数实际上不实用,我自己编写了精确计时函数反而代码更精简,思路更简单。思路是调用后,变量清零,然后使用时钟来的曾变量,不断比较变量与延迟的数值,相等则退出函数。代码和步骤如下:
    
    i.        定义通用变量:u16 Tic_Val=0; //变量用于精确计时
    
    ii.        在stm32f10x_it.c文件中相应定义:
    
    extern u16 Tic_Val;//在本文件引用MAIN.c定义的精确计时变量
    
    iii.        定义函数名称:void Tic_Delay(u16 Tic_Count);//精确延迟函数
    
    iv.        精确延时函数:
    
    void Tic_Delay(u16 Tic_Count)               //精确延时函数
    
    {         Tic_Val=0;                           //变量清零
    
      while(Tic_Val != Tic_Count){printf("");}//计时
    
    }
    
    v.        在stm32f10x_it.c文件中void SysTickHandler 函数里面添加
    
         Tic_Val++;//变量递增
    
    vi.        调用代码:Tic_Delay(10);   //精确延时
    
    vii.        疑问:如果去掉计时行那个没用的printf("");函数将停止工作,这个现象很奇怪
    
    C语言功底问题。是的,那个“注意事项”最后的疑问的原因就是这个
    
    Tic_Val应该改为vu16
    
    while(Tic_Val != Tic_Count){printf("");}//计时
    
    就可以改为:
    
    while(Tic_Val != Tic_Count);              //检查变量是否计数到位
    
    STM32笔记之十三:恶搞,两只看门狗
    
    a)        目的:
    
    了解两种看门狗(我叫它:系统运行故障探测器和独立系统故障探测器,新手往往被这个并不形象的象形名称搞糊涂)之间的区别和基本用法。
    
    b)        相同:
    
    都是用来探测系统故障,通过编写代码定时发送故障清零信号(高手们都管这个代码叫做“喂狗”),告诉它系统运行正常。一旦系统故障,程序清零代码(“喂狗”)无法执行,其计数器就会计数不止,直到记到零并发生故障中断(狗饿了开始叫唤),控制CPU重启整个系统(不行啦,开始咬人了,快跑……)。
    
    c)        区别:
    
    独立看门狗Iwdg——我的理解是独立于系统之外,因为有独立时钟,所以不受系统影响的系统故障探测器。(这条狗是借来的,见谁偷懒它都咬!)主要用于监视硬件错误。
    
    窗口看门狗wwdg——我的理解是系统内部的故障探测器,时钟与系统相同。如果系统时钟不走了,这个狗也就失去作用了。(这条狗是老板娘养的,老板不干活儿他不管!)主要用于监视软件错误。
    
    d)        初始化函数定义:鉴于两只狗作用差不多,使用过程也差不多初始化函数栓一起了,用的时候根据情况删减。
    
    void WDG_Configuration(void);
    
    e)        初始化函数调用:
    
    WDG_Configuration();
    
    f)        初始化函数
    
    void WDG_Configuration()                //看门狗初始化
    
    {
    
    //软件看门狗初始化
    
      WWDG_SetPrescaler(WWDG_Prescaler_8); //时钟8分频4ms
    
    // (PCLK1/4096)/8= 244 Hz (~4 ms)
    
       WWDG_SetWindowValue(65);                    //计数器数值
    
      WWDG_Enable(127);                   //启动计数器,设置喂狗时间
    
    // WWDG timeout = ~4 ms * 64 = 262 ms
    
       WWDG_ClearFlag();                   //清除标志位
    
      WWDG_EnableIT();                    //启动中断
    
    //独立看门狗初始化
    
      IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);//启动寄存器读写
    
      IWDG_SetPrescaler(IWDG_Prescaler_32);//40K时钟32分频
    
      IWDG_SetReload(349);                 //计数器数值
    
      IWDG_ReloadCounter();                //重启计数器
    
      IWDG_Enable();                       //启动看门狗
    
    }
    
    g)        RCC初始化:只有软件看门狗需要时钟初始化,独立看门狗有自己的时钟不需要但是需要systic工作相关设置。
    
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE);
    
    h)        独立看门狗使用systic的中断来喂狗,所以添加systic的中断打开代码就行了。软件看门狗需要在NVIC打开中断添加如下代码:
    
      NVIC_InitStructure.NVIC_IRQChannel = WWDG_IRQChannel; //通道
    
      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; //占先中断等级
    
      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;      //响应中断优先级
    
      NVIC_Init(&NVIC_InitStructure);                        //打开中断
    
    i)        中断程序,软件看门狗在自己的中断中喂狗,独立看门狗需要使用systic的定时中断来喂狗。以下两个程序都在stm32f10x_it.c文件中。
    
    void WWDG_IRQHandler(void)
    
    {
    
      WWDG_SetCounter(0x7F);          //更新计数值
    
    WWDG_ClearFlag();               //清除标志位
    
    }
    
    void SysTickHandler(void)
    
    {  IWDG_ReloadCounter();         //重启计数器(喂狗)
    
    }
    
    j)        注意事项:
    
    i.        有狗平常没事情可以不理,但是千万别忘了喂它,否则死都不知道怎么死的!
    
    ii.        初始化程序的调用一定要在systic的初始化之后。
    
    iii.        独立看门狗需要systic中断来喂,但是systic做别的用处不能只做这件事,所以我写了如下几句代码,可以不影响systic的其他应用,其他systic周期代码也可参考:
    
    第一步:在stm32f10x_it.c中定义变量
    
    int Tic_IWDG;           //喂狗循环程序的频率判断变量
    
    第二步:将SysTickHandler中喂狗代码改为下面:
    
    Tic_IWDG++;             //变量递增
    
    if(Tic_IWDG>=100)       //每100个systic周期喂狗
    
    {  IWDG_ReloadCounter();//重启计数器(喂狗)
    
      Tic_IWDG=0;          //变量清零
    
    }
    
    
    展开全文
  • STM32中断优先级分组概念

    万次阅读 2016-12-20 09:19:23
    Cortex-M3允许具有较少中断源时使用较少的寄存器位指定中断源的优先级,因此STM32把指定中断优先级的寄存器位减少到4位,这4个寄存器位的分组方式如下:第0组:所有4位用于指定响应优先级第1组:最高1位用于指定抢占...

    在进行STM32f103的时候,进行中断分组的相关概念
    Cortex-M3允许具有较少中断源时使用较少的寄存器位指定中断源的优先级,因此STM32把指定中断优先级的寄存器位减少到4位,这4个寄存器位的分组方式如下:

    第0组:所有4位用于指定响应优先级

    第1组:最高1位用于指定抢占式优先级,最低3位用于指定响应优先级

    第2组:最高2位用于指定抢占式优先级,最低2位用于指定响应优先级

    第3组:最高3位用于指定抢占式优先级,最低1位用于指定响应优先级

    第4组:所有4位用于指定抢占式优先级

    可以通过调用STM32的固件库中的函数NVIC_PriorityGroupConfig()选择使用哪种优先级分组方式,这个函数的参数有下列5种:

    NVIC_PriorityGroup_0=> 选择第0组

    NVIC_PriorityGroup_1=> 选择第1组

    NVIC_PriorityGroup_2=> 选择第2组

    NVIC_PriorityGroup_3=> 选择第3组

    NVIC_PriorityGroup_4=> 选择第4组

    接下来就是指定中断源的优先级,下面以一个简单的例子说明如何指定中断源的抢占式优先级和响应优先级:
    // 选择使用优先级分组第1组
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);

    // 使能EXTI0中断
    NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQChannel;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1; // 指定抢占式优先级别1

    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; // 指定响应优先级别0
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    // 使能EXTI9_5中断
    NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQChannel;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; // 指定抢占式优先级别0
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1; // 指定响应优先级别1
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);

    要注意的几点是:

    1)如果指定的抢占式优先级别或响应优先级别超出了选定的优先级分组所限定的范围,将可能得到意想不到的结果;

    2)抢占式优先级别相同的中断源之间没有嵌套关系;

    3)如果某个中断源被指定为某个抢占式优先级别,又没有其它中断源处于同一个抢占式优先级别,则可以为这个中断源指定任意有效的响应优先级别。

    展开全文
  • STM32 中断优先级

    2020-02-13 20:33:37
    1.ARM cortex_m3 内核支持 256 个中断(16 个内核+240 外部)和可编程 256 级中断优先级 的设置,与其相关的中断控制和中断优先级控制寄存器(NVIC、SYSTICK 等)也都属于 cortex_m3 内核的部分。STM32 采用了 ...

    1.ARM cortex_m3 内核支持 256 个中断(16 个内核+240 外部)和可编程 256 级中断优先级 的设置,与其相关的中断控制和中断优先级控制寄存器(NVIC、SYSTICK 等)也都属于 cortex_m3 内核的部分。STM32 采用了 cortex_m3 内核,所以这部分仍旧保留使用,但 STM32 并没有使用 cortex_m3 内核全部的东西(如内存保护单元 MPU 等),因此它的 NVIC 是 cortex_m3 内核的 NVIC 的子集。 
     
    2.STM32 目前支持的中断共为 84 个(16 个内核+68 个外部),和 16 级可编程中断优先级 的设置(仅使用中断优先级设置 8bit 中的高 4 位,见后面解释)。《参考最新 101xx-107xx STM32 Reference manual, RM0008》。 
     
    3.以下主要对“外部中断通道”进行说明。 对于 cortex_m3 内核所支持的 240 个外部中断,我在这里使用了“中断通道”这个概 念,因为尽管每个中断对应一个外围设备,但该外围设备通常具备若干个可以引起中断的 中断源或中断事件。而该设备的所有的中断都只能通过该指定的“中断通道”向内核申请 中断。因此,下面关于中断优先级的概念都是针对“中断通道”的。当该中断通道的优先 级确定后,也就确定了该外围设备的中断优先级,并且该设备所能产生的所有类型的中断, 都享有相同的通道中断优先级。至于该设备本身产生的多个中断的执行顺序,则取决于用 户的中断服务程序。 
     
    4. STM32 可以支持的 68 个外部中断通道,已经固定的分配给相应的外部设备。每个中断 通道都具备自己的中断优先级控制字节 PRI_n(8 位,但在 STM32 中只使用 4 位,高 4 位有 效),每 4 个通道的 8 位中断优先级控制字(PRI_n)构成一个 32 位的优先级寄存器(Priority Register)。68 个通道的优先级控制字至少构成 17 个 32 位的优先级寄存器,它们是 NVIC 寄存器中的一个重要部分。 
     
    5.对于这 4bit 的中断优先级控制位还必须分成 2 组看:从高位开始,前面是定义抢先式优 先级的位,后面用于定义子优先级。4bit 的分组组合可以有以下几种形式: 
     
     
    6.在一个系统中,通常只使用上面 5 种分配情况的一种,具体采用哪一种,需要在初始化 时写入到一个 32 位寄存器 AIRC(Application Interrupt and Reset Control Register)
    的第[10:8]这 3 个位中。这 3 个 bit 位有专门的称呼:PRIGROUP(具体写操作后面介绍)。 比如你将 0x05(即上表中的编号)写到 AIRC 的[10:8]中,那么也就规定了你的系统中只 有 4 个抢先式优先级,相同的抢先式优先级下还可以有 4 个不同级别的子优先级。 
     
    7.AIRC 中 PRIGROUP 的值规定了设置和确定每个外部中断通道优先级的格式。例如,在上 面将 0x05 写入了 AIRC 中 PRIGROUP,也就规定了当前系统中只能有 4 个抢先式优先级,相 同的抢先式优先级下还可以有 4 个不同级别的子优先级,他们分别为: 
     

     
    8.如果在你的系统中使用了 TIME2(中断通道 28)和 EXTI0(中断通道 6)两个中断,而 TIME2 中断必须优先响应,而且当系统在执行 EXIT0 中断服务时也必须打断(抢先、嵌套), 就必须设置 TIME2 的抢先优先级比 EXTI0 的抢先优先级要高(数目小)。假定 EXTI0 为 2 号 抢先优先级,那么 TIME2 就必须设置成 0 或 1 号抢先优先级。这些工作需要在 AIRC 中的 PRIGROUP 设置完成,确定了整个系统所具有的优先级个数后,再分别对每个中断通道(设 备)进行设置。 
     
    9.具体优先级的确定和嵌套规则。ARM cortex_m3(STM32)规定

    a/ 只能高抢先优先级的中断可以打断低抢先优先级的中断服务,构成中断嵌套。

    b/ 当 2(n)个相同抢先优先级的中断出现,它们之间不能构成中断嵌套,但 STM32 首 先响应子优先级高的中断。

    c/ 当 2(n)个相同抢先优先级和相同子优先级的中断出现,STM32 首先响应中断通道 所对应的中断向量地址低的那个中断(见 ROM0008,表 52)。

    具体一点:

    0 号抢先优先级的中断,可以打断任何中断抢先优先级为非 0 号的中断;1 号抢先优先 级的中断,可以打断任何中断抢先优先级为 2、3、4 号的中断;……;构成中断嵌套。

    如果两个中断的抢先优先级相同,谁先出现,就先响应谁,不构成嵌套。如果一起出 现(或挂在那里等待),就看它们 2 个谁的子优先级高了,如果子优先级也相同,就看它们 的中断向量位置了。 
     
    10.上电 Reset 后,寄存器 AIRC 中 PRIGROUP[10:8]的值为 0(编号 0),因此此时系统使 用 16 个抢先优先级,无子优先级。另外由于所有外部中断通道的优先级控制字 PRI_n 也都 是 0,所以根据上面的定义可以得出,此时 68 个外部中断通道的抢先优先级都是 0 号,没 有子优先级的区分。故此时不会发生任何的中断嵌套行为,谁也不能打断当前正在执行的中 断服务。当多个中断出现后,则看它们的中断向量地址:地址越低,中断级别越高,STM32 优先响应。 注意:此时内部中断的抢先优先级也都是 0 号,由于它们的中断向量地址比外部中断向 量地址都低,所以它们的优先级比外部中断通道高,但如果此时正在执行一个外部中断服务, 它们也必须排队等待,只是可以插队,当正在执行的中断完成后,它们可以优先得到执行。 
     
    了解以上基本概念还是不够的,还要了解具体中断的控制有那些途径,中断服务程序 如何正确的编写。下面的描述主要以 TIME2 通道为例。 
     
    中断控制 
     
    1.对于 STM32 讲,外部中断通道位置 28(35 号优先级)是给外部设备 TIME2 的,但 TIME2 本身能够引起中断的中断源或事件有好多个,比如更新事件(上溢/下溢)、输入捕获、输出 匹配、DMA 申请等。所有 TIME2 的中断事件都是通过一个 TIME2 的中断通道向 STM32 内核提 出中断申请,那么 STM32 中如何处理和控制 TIME2 和它众多的、不同的、中断申请呢? 
     
    (题外话:STM32 中的一个通用定时计数器,就比 8 位控制器(如 AVR,MCS-51 就更不必说了)中 TIME
    要复杂多了。学过 AVR 的,可能对输入捕获、输出匹配等还有概念,但如果你学的标准架构的 MCS-51,那
    么上手 32 位可能困难就更多了。所以我一直推荐学习 8 位机应该认真的从 AVR 开始。尽管 51 有很大的市
    场,价格也相对便宜,但从长远的眼光看问题,从后续掌握 32 位的使用,考虑到学生的可持续发展,AVR
    应该是比较好的选择。) 
     
    2.cortex_m3 内核对于每一个外部中断通道都有相应的控制字和控制位,用于单独的和总 的控制该中断通道。它们包括有:

    •  中断优先级控制字:PRI_n(上面提到的)
    •  中断允许设置位:在 ISER 寄存器中
    •  中断允许清除位:在 ICER 寄存器中
    •  中断悬挂 Pending(排队等待)位置位:在 ISPR 寄存器中(类似于置中断通道标志位)
    •  中断悬挂 Pending(排队等待)位清除:在 ICPR 寄存器中(用于清除中断通道标志位)
    •  正在被服务(活动)的中断(Active)标志位:在 IABR 寄存器中,(只读,可以知道当 前内核正在处理哪个中断通道) 

     
    因此,与 TIME2 中断通道相关的,在 NVIC 中有 13 个 bits,它们是 PRI_28(IP[28]), 的 8 个 bits(只用高 4 位);加上中断通道允许,中断通道清除(相当禁止中断),中断通道 Pending 置位(我的理解是中断请求发生了,但当前有其它中断服务在执行,你的中断级别 又不能打断别人,所以 Pending 等待,这个应该由硬件自动置位的),中断 Pending 位清除 (可以通过软件将本次中断请求、且尚处在 Pending 状态,取消掉),正在被服务的中断 (Active)标志位,各 1 个 bit。 上面的控制字和控制位都是分布在 NVIC 的寄存器组中的,可惜在 STM32 手册中竟然不 给出任何的解释和说明。 
     
    3.作为外围设备 TIME2 本身也包括更具体的,管理自己不同中断的中断控制器(位),它们 主要是自身各个不同类型中断的允许控制位,和各自相应的中断标志位(这个在 STM32 的手 册中有详细的说明了)。 
     
    4.在弄清楚 2、3 两点的基础上,我们可以全程、全面和综合的来了解 TIME2 的中断过程, 以及如何控制的。 
     
    a/ 初始化过程 首先要设置寄存器 AIRC 中 PRIGROUP 的值,规定系统中的抢先优先级和子优先级的个数
    (在 4 个 bits 中占用的位数); 设置 TIME2 本身的寄存器,允许相应的中断,如允许 UIE(TIME2_DIER 的第[0]位) 设置 TIME2 中断通道的抢先优先级和子优先级(IP[28],在 NVIC 寄存器组中) 设置允许 TIME2 中断通道。在 NVIC 寄存器组的 ISER 寄存器中的一位。 
     
    b/ 中断响应过程 当 TIME2 的 UIE 条件成立(更新,上溢或下溢),硬件将 TIME2 本身寄存器中 UIE 中断 标志置位,然后通过 TIME2 中断通道向内核申请中断服务。 此时内核硬件将 TIME2 中断通道的 Pending 标志置位(相当与中断通道标志置位),表 示 TIME2 有中断申请。 如果当前有中断在处理,TIME2 的中断级别不够高,那么就保持 Pending 标志,当然用 户可以在软件中通过写 ICPR 寄存器中相应的位把本次中断清除掉。 当内核有空,开始响应 TIME2 的中断,进入 TIME2 的中断服务。此时硬件将 IABR 寄存 器中相应的标志位置位,表示 TIME2 中断正在被处理。同时硬件清除 TIME2 的 Pending 标志 位。 
     
    c/ 执行 TIME2 的中断服务程序 所有 TIME2 的中断事件,都是在一个 TIME2 中断服务程序中完成的,所以进入中断程序 后,中断程序需要首先判断是哪个 TIME2 的具体事件的中断,然后转移到相应的服务代码段 去。 注意不要忘了把该具体中断事件的中断标志位清除掉,硬件是不会自动清除 TIME2 寄存 器中具体的中断标志位的。 如果 TIME2 本身的中断事件多于 2 个,那么它们服务的先后次序就由用户编写的中断服 务决定了。换句话说,对于 TIME2 本身的多个中断的优先级,系统是不能设置的。所以用户 在编写服务程序时,应该根据实际的情况和要求,通过软件的方式,将重要的中断优先处理 掉。 当然你也可以每次中断服务只处理其中的一个,然后再次进入中断,处理下一个。 
     
    d/ 中断返回 内核执行完中断服务后,便进入中断返回过程,在这个过程中需要: 硬件将 IABR 寄存器中相应的标志位清另,表示该中断处理完成 如果 TIME2 本身还有中断标志位置位,表示 TIME2 还有中断在申请,则重新将 TIME2 的 Pending 标志置为 1,等待再次进入 TIME2 的中断服务。 
     
    以上中断过程在《ARM Cortex-M3 权威指南》中有详细描述,并配合时序图说明,可以 参考。 
     
    上述两点弄清楚后,就可以在 ST 提供的函数库的帮助下,正确的设置和使用 STM32 的 中断系统了。 
     
     
     
    如果你要了解更深入的东西,或者直接对寄存器操作,还要继续望下看。 
     
    三、深入 NVIC 
     
    1. 看看 Cortex-M3 中与 NVIC 相关的寄存器有那些 
     
    SysTick                                    Control and Status Register                                 Read/write                           0xE000E010 SysTick                                    Reload Value Register                                         Read/write                            0xE000E014 SysTick                                    Current Value Register                                        Read/write clear                    0xE000E018 SysTick                                    Calibration Value Register                                   Read-only                             0xE000E01C //==================

    Irq 0 to 31                                 Set Enable Register                                            Read/write                             0xE000E100 . 

    Irq 224 to 239                           Set Enable Register                                            Read/write                             0xE000E11C //=================

    Irq 0 to 31                              Clear Enable Register                                           Read/write                                 0xE000E180 . . . Irq 224 to 239                        Clear Enable Register                                          Read/write                                 0xE000E19C //==================

    Irq 0 to 31                              Set Pending Register                                            Read/write                                 0xE000E200 . . . . Irq 224 to 239                        Set Pending Register                                            Read/write                                 0xE000E21C //==================

    Irq 0 to 31                              Clear Pending Register                                          Read/write                                 0xE000E280 . . Irq 224 to 239                       Clear Pending Register                                           Read/write                                 0xE000E29C //==================

    Irq 0 to 31                                Active Bit Register                                                Read-only                                  0xE000E300 . . Irq 224 to 239                          Active Bit Register                                               Read-only                                   0xE000E31C //===================

    Irq 0 to 3                                Priority Register                                                      Read/write                                 0xE000E400 . . . Irq 224 to 239                        Priority Register                                                      Read/write                                  0xE000E4EC //========================

    CPUID Base Register                                                                                        Read-only                                   0xE000ED00 Interrupt Control State Register                                                              Read/write or read-only                         0xE000ED04 Vector Table Offset Register                                                                          Read/write                                      0xE000ED08 Application Interrupt/Reset Control Register                                         Read/write                                               0xE000ED0C System Control Register                                                                            Read/write                                          0xE000ED10 Configuration Control Register                                                                Read/write                                             0xE000ED14 System Handlers 4-7 Priority Register                                                    Read/write                                             0xE000ED18 System Handlers 8-11 Priority Register                                                    Read/write                                            0xE000ED1C System Handlers 12-15 Priority Register                                                    Read/write                                           0xE000ED20 . . . . . 
     
    2.STM32 中用了那些 
     
    下面是从 ST 公司提供的函数库的头文件得到的,库的版本是 v3.1.0

    /* memory mapping struct for Nested Vectored Interrupt Controller (NVIC) */

    typedef struct {  

    __IO uint32_t ISER[8];   /*!< Interrupt Set Enable Register */    

       uint32_t RESERVED0[24];  

    __IO uint32_t ICER[8];   /*!< Interrupt Clear Enable Register */      

     uint32_t RSERVED1[24];  

    __IO uint32_t ISPR[8];   /*!< Interrupt Set Pending Register */      

     uint32_t RESERVED2[24];  

    __IO uint32_t ICPR[8];   /*!< Interrupt Clear Pending Register */    

       uint32_t RESERVED3[24];  

    __IO uint32_t IABR[8];   /*!< Interrupt Active bit Register */    

       uint32_t RESERVED4[56];  

    __IO uint8_t  IP[240];   /*!< Interrupt Priority Register, 8Bit wide */  

         uint32_t RESERVED5[644];  

    __O  uint32_t STIR;    /*!< Software Trigger Interrupt Register */

    }  NVIC_Type; 
     
    a/  寄存器 ISER、ICER、ISPR、ICPR、IABR 在 STM32 中都使用的 8 个(实际 3 个就够 了,后面的留在后面扩充?)。这些 32 位的寄存器中每一位对应了一个中断通道相应的标志。
     比如地址在 0xE000E100 的 ISER[0]这个 32 位的寄存器,第 0 位是中断通道 0 的允许位, 第 1 位是中断通道 1 的允许标志……第 31 位是中断通道 31 的允许位;接下来地址在 0xE000E104 的 ISER[1]则是中断通道 32-63 的允许位。ICER、ISPR、ICPR、IABR 的结构相 同,只是含义不同。 
     
    注意是对这些寄存器的操作:写 1 表示置位或清除,写 0 无任何影响。 
     
    例如:对地址在 0xE000E100 的 ISER[0]的第 0 位写 1,表示允许中断通道 0 中断; 但对 0xE000E100 的 ISER[0]的第 0 位写 0,则没有任何作用,该位保持不变。 如果要禁止中断通道 0 的中断响应,那么就必须: 对地址 0xE000E180 的 ICER[0]的第 0 位写 1,表示禁止中断通道 0 的中断; 对 0xE000E180 的 ICER[0]的第 0 位写 0,也是不起任何作用的。 
     
    b/ IP[240]用于定义 240 个外部中断通道的优先级,每 1 个字节对应一个中断通道。4 个 中断通道的 IP[n]字构成一个 32 位的寄存器。在 STM32 中最多有 68 个外部中断通道,每个 IP[n]的 1 个字节中只使用高 4 位(见前面介绍)。IP[n]的结构如下: 
     
     
    c/ 在 ST 公司提供的函数库的头文件中另一个数据结构中,还有一个重要的 32 位寄存器 需要关注 :AIRCR 
     

    它就是地址在 0xE000ED0C 的 32 位寄存器 AIRCR(Application Interrupt/Reset Control Register),该寄存器的[10:8]3 位就是 PRIGROUP 的定义位,它的值规定了系统中 有多少个抢先级中断和子优先级中断。而 STM32 只使用高 4 位 bits,其可能的值如下(来 自 ST 的函数库头文件中的定义) 
     
    #define NVIC_PriorityGroup_0          ((uint32_t)0x700) /*!< 0 bits for pre-emption priority 
                                                                4 bits for subpriority */ 
    #define NVIC_PriorityGroup_1         ((uint32_t)0x600) /*!< 1 bits for pre-emption priority 
                                                                3 bits for subpriority */ 
    #define NVIC_PriorityGroup_2         ((uint32_t)0x500) /*!< 2 bits for pre-emption priority 
                                                                2 bits for subpriority */ 
    #define NVIC_PriorityGroup_3         ((uint32_t)0x400) /*!< 3 bits for pre-emption priority 
                                                                1 bits for subpriority */ 
    #define NVIC_PriorityGroup_4         ((uint32_t)0x300) /*!< 4 bits for pre-emption priority 
                                                                0 bits for subpriority */ 
     
    由于这个寄存器相当重要,为了防止误操作(写),因此当改写这个寄存器的内容时,
    必须要同时向这个寄存器的高 16 位[31:16]写验证字(Register key) 0x05FA。 
     
    例如:SBC->AIRCR |= (0x05FA0000 || 0x300); // 设置系统中断有 16 个抢先优先 // 级,无子优先级 
     
     
    d/ 下面的定义与SYSTICK相关,有时也会用到的。

    /* memory mapping struct for SysTick */

    typedef struct {

      __IO uint32_t CTRL;  /*!< SysTick Control and Status Register */  

    __IO uint32_t LOAD;       /*!< SysTick Reload Value Register       */  

    __IO uint32_t VAL;        /*!< SysTick Current Value Register      */  

    __I  uint32_t CALIB;      /*!< SysTick Calibration Register        */

    } SysTick_Type; 
     
    e/ 另外的几个寄存器,也是需要使用的(请具体参考相关的资料) 
     
    __IO uint8_t  SHP[12]; /*!<System Handlers Priority Registers(4-7,8-11,12-15) */ 
     
    同每个外部中断通道优先级定义字相同,它们是内核中断通道4-15的优先级定义字所在 的寄存器。用户可以通过设置SHP[n],改变内部中断通道的优先级。 
     
    __IO uint32_t VTOR;  /*!< Vector Table Offset Register  */ 
     
    如果你的代码要在RAM中启动执行,就需要对这个寄存器进行设置。 

    展开全文
  • stm32中断优先级

    2017-09-29 11:18:26
    CM3 内核支持 256 个中断,STM32 并没有使用 CM3 内核的全部只用了它的一部分。 STM32 有 84 个中断,包括 16 个内核中断和...与 NVIC 相关的寄存器中IPR[15]:是一个中断优先级控制的寄存器组由15个32bit的寄存器组成.
  • STM32中断优先级概念

    千次阅读 2014-10-24 11:09:03
    STM32 目前支持的中断共为 84 个(16 个内核+68 个外部),16 级可编程中断优先级 的设置(仅使用中断优先级设置 8bit 中的高 4 位)和16个抢占优先级(因为抢占优先级最多可以有四位数)。 二:优先级判断 STM32...
  • STM32中断优先级管理

    2019-06-13 11:32:00
    1、先对优先级进行分组,数值越小所代表的优先级就越高 组 AIRCR[10:8] Bit[7:4] 分配结果 0 111 0:4 0 位抢占优先级,4 位响应优先级 1 110 1:3 1 位抢占优先级,3 位响应优先级 ...
  • STM32中断优先级分组

    千次阅读 2015-11-26 14:14:33
    我们知道:STM32把指定中断优先级的寄存器的MSB4位有效,共有以下5种分组方式: 第0组方式:所有4位用于响应优先级 第1组方式:最高1位用于抢占式优先级,最低3位用于响应优先级 第2组方式:最高2位用于抢占式
  • 关于 STM32 中断优先级

    2012-04-25 09:33:42
    一:综述STM32 目前支持的中断共为 84 个(16 个内核+68 个外部), 16 级可编程中断优先级的设置(仅使用中断优先级设置 8bit 中的高 4 位)和16个抢占优先级(因为抢占优先级最多可以有四位数)。二:优先级判断...

空空如也

1 2 3 4 5 ... 20
收藏数 4,471
精华内容 1,788
关键字:

stm32中断优先级