STM32F4从入门到深入，很好的教程系列转过来一起学习！

奋斗哥

通用定时器

      通用定时器（TIM2 to TIM5）包括由可编程的分频器驱动一个的16位或32位自动重载计数器。它们可用于多种用途，包括测量输入信号的脉冲长度（输入捕获）或生成的输出波形（输出比较和PWM）。可以使用定时器的预分频器和RCC时钟控制器分频器调制从几微秒到几毫秒的脉冲长度和波形周期。它们是完全独立的，不共享任何资源。

主要特点：

通用TIMx定时器功能包括：

1.  16位（TIM3和TIM4）或32位（TIM2和TIM5）计数器，向上，向下，向上/向下自动重装计数。

2.  16位可编程预分频器（可在运行时改变）用于在1到65535之间细分计数器的时钟频率。

3.  多达4个独立的通道可用于：

- 输入捕捉

- 输出比较

- PWM生成（边缘和中心对齐模式）

- 单脉冲输出模式

4. 使用外部信号控制定时器和定时器互连的同步电路

5. 对以下事件中断/ DMA的生成：

- 更新：计数器溢出/下溢，计数器初始化（通过软件或内部/外部触发）

- 触发事件（计数器开始，停止，初始化或内部/外部触发计数）

- 输入捕捉

- 输出比较

6. 支持针对定位增量（正交）编码器和霍尔传感器电路

7. 触发输入作为外部时钟或者按周期的电流管理

奋斗哥

PWM

         脉宽调制模式可以生成一个由TIMx_ARR寄存器的值确定频率和TIMx_CCRx寄存器的值确定占空比的信号。

         可以对每个通道独立选择PWM模式，（ OCx输出一个PWM信号）在TIMx_CCMRx寄存器的OCxM位写110（PWM模式1）或111（PWM模式2）。必须通过设置TIMx_CCMRx寄存器的OCxPE位，启用相应的预装载寄存器，最后还要设置TIMx_CR1寄存器的ARPE位，(在向上计数或中心对称模式中)使能自动重装载的预装载寄存器。

       仅当发生一个更新事件的时候，预装载寄存器才能被传送到影子寄存器，因此在计数器开始计数之前，必须通过设置TIMx_EGR寄存器中的UG位来初始化所有的寄存器。

        OCx的极性可以通过软件在TIMx_CCER寄存器中的CCxP位设置，它可以设置为高电平有效或低电平有效。TIMx_CCER寄存器中的CCxE位控制OCx输出使能。详见TIMx_CCERx寄存器的描述。

配置步骤：

1.     使能相关时钟。

2.     配置相关的引脚模式、速度、以及复用功能。

3.     使能TIM时钟

4.     设置分频。

5.     设置周期。（ARR的值）周期=（PSC+1）* ARR / TIMx时钟

6.     产生一次更新事件，更新影子寄存器的值。

7.     在CCMR中设置PWM模式。

8.     设置各通道占空比。占空比= CCRx / ARR。

9.     使能比较输出。

10.  启动预装载。

11.  打开定时器。

程序：

1. /************************************
   
2.     标题：输出4路PWM
   
3.     软件平台：IAR for ARM6.21
   
4.     硬件平台：stm32f4-discovery
   
5.     主频：168M
   
6.    
   
7.     author：小船
   
8.     data：2012-02-08
   
9. *************************************/
   
10. 
    
11. #include <stm32f4xx.h>
    
12. 
    
13. void main ()
    
14. {   
    
15. 
    
16.   SCB->AIRCR = 0x05FA0000 | 0x400;  //中断优先级分组 抢占：响应=3:1
    
17.   
    
18.   RCC->AHB1ENR |= (1<<2); //打开GPIOC时钟
    
19.   GPIOC->MODER |= 0X000AA000;//pc6789第二功能
    
20.         //推挽输出
    
21.   GPIOC->OSPEEDR |= 0x000ff000;//速度100m
    
22.   GPIOC->PUPDR |= 0x00055000;//上拉  
    
23.   
    
24.   GPIOC->AFR[0] |= 0x22000000;//pc6789第二功能AF2
    
25.   GPIOC->AFR[1] |= 0x00000022;
    
26.   
    
27.   RCC->APB1ENR |= (1<<1); //打开TIM3时钟
    
28.   TIM3->PSC = 83; //对时钟84M进行84分频，使得计数频率为1M
    
29.   TIM3->ARR = 10000;  //周期10ms
    
30.   TIM3->EGR |= 1; //产生一次更新事件
    
31.   
    
32.   TIM3->CCMR1 |= 0x6060;//PWM模式1
    
33.   TIM3->CCMR2 |= 0x6060;//PWM模式1
    
34.   
    
35.   TIM3->CCR1 = 8000;//设置第一通道占空比80%
    
36.   TIM3->CCR2 = 6000;//设置第二通道占空比60%
    
37.   TIM3->CCR3 = 4000; //设置第三通道占空比40%
    
38.   TIM3->CCR4 = 2000; //设置第四通道占空比20%
    
39.   
    
40.   TIM3->CCER |= 0x1111;//使能比较输出
    
41.   
    
42.   TIM3->CCMR1 |= 0x0808;//启动预装载
    
43.   TIM3->CCMR2 |= 0x0808;
    
44.   
    
45.   TIM3->CR1 |= 1; //开始计时
    
46. 
    
47.   while(1)
    
48.   {
    
49.   };
    
50. }
    

复制代码

奋斗哥

DAC

       Stm32f4内嵌的DAC是12位数字输入，电压输出的数模转换器。DAC可以配置为8位或12位模式，也可以与DMA控制器配合使用。DAC工作在12位模式时，数据可以设置成左对齐或右对齐。DAC模块有2个输出通道，每个通道都有单独的转换器。在双DAC模式下，2个通道可以独立地进行转换，也可以同时进行转换并同步地更新2个通道的输出。DAC可以通过引脚输入参考电压VREF+以获得更精确的转换结果。

        

主要特点：

2个DAC转换器：每个转换器对应1个输出通道

8位或者12位单调输出

12位模式下数据左对齐或者右对齐

同步更新功能

噪声波形生成

三角波形生成

双DAC通道同时或者分别转换

每个通道都有DMA功能

外部触发转换

输入参考电压VREF+

设置步骤：

1.     设置相关GPIO（PA4、5）。

2.     若时钟源为TIMx更新事件，则设置TIMx。

3.     使能DAC时钟

4.     设置触发源，开启相关触发通道，如果用DMA，是否允许数据错误中断。

5.     如果用DMA。配置相关DMA数据流。

程序：

1. /************************************
   
2.     标题：DAC
   
3.     软件平台：IAR for ARM6.21
   
4.     硬件平台：stm32f4-discovery
   
5.     主频：168M
   
6.    
   
7.     author：小船
   
8.     data：2012-02-12
   
9. *************************************/
   
10. 
    
11. #include <stm32f4xx.h>
    
12. #include "MyDebugger.h"
    
13. #include "sintable.h"
    
14. 
    
15. 
    
16. void main ()
    
17. {   
    
18. 
    
19.   SCB->AIRCR = 0x05FA0000 | 0x400;  //中断优先级分组 抢占：响应=3:1
    
20. 
    
21.   /***GPIO设置***/
    
22.   RCC->AHB1ENR |= (1<<0); //打开GPIOA时钟
    
23.   GPIOA->MODER |= 0x00000F00;//PA4、5模拟模式
    
24.   GPIOA->PUPDR &= 0xfffff0ff;//无上拉无下拉   
    
25.   
    
26.   /***定时器设置***/
    
27.   RCC->APB1ENR |= (1<<4);//打开TIM6时钟
    
28.   TIM6->PSC = 0;
    
29.   TIM6->ARR = 83;  //使得更新事件频率为1m
    
30.   TIM6->CR2 |=  0x00000020;//更新事件输出
    
31.   TIM6->CR1 |= 1; //开始计时
    
32.   
    
33.   /***DAC设置***/
    
34.   RCC->APB1ENR |= (1<<29); //使能DAC时钟
    
35.   DAC->CR &= 0xffff0000;
    
36.   /*
    
37.   使能DMA堵塞中断
    
38.   使能通道1触发
    
39.   */
    
40.   DAC->CR |= ( (1<<13) | (1<<2) );  
    
41.   NVIC->IP[54] = 0xA0;
    
42.   NVIC->ISER[1] |= (1<<(54-32));
    
43. 
    
44.   /***DMA设置***/
    
45.   RCC->AHB1ENR |= (1<<21); //使能DMA1时钟
    
46.   DAC->CR &= ~(1<<12);//DAC dma发送模式除能
    
47.   DMA1_Stream5->CR &= 0xFFFFFFFE; //除能DMA1_Stream5
    
48.   while(DMA1_Stream5->CR & 0x00000001);//确保DMA可以被设置
    
49.   DMA1->HIFCR |= 0x000004f0;//传送前清空DMA1_Stream5所有中断标志
    
50.   DMA1_Stream5->PAR = (uint32_t)&DAC->DHR12R1;//设置外设地址
    
51.   DMA1_Stream5->M0AR = (uint32_t)SinTable; //设置内存地址
    
52.   DMA1_Stream5->CR |= 0x0002800;//16位数据
    
53.   DMA1_Stream5->NDTR = 1024; //设置dma传输数据的数量
    
54.   /*
    
55.     设置dma通道7，即DAC1
    
56.     优先级Medium
    
57.     传输方向内存到外设
    
58.     内存递增模式
    
59.     循环模式
    
60.   */
    
61.   DMA1_Stream5->CR |= ( 0x0e000000 | 0x00010000 | (1<<6)
    
62.                         | (1<<10) | (1<<8) );
    
63.   
    
64.   DMA1_Stream5->CR |= 1; //DMA数据流5使能
    
65.   
    
66.   DAC->CR |= (1<<0);   //DAC通道1使能
    
67. 
    
68.   DAC->CR |= (1<<12);//DAC dma发送模式使能  
    
69.    
    
70.   MyDebugger_Init();
    
71. 
    
72.   while(1)
    
73.   {
    
74.   };
    
75. }
    
76. 
    
77. void TIM6_DAC_IRQHandler(void)
    
78. {
    
79.   if( DAC->SR & (1<<13) )
    
80.   {
    
81.     MyDebugger_LEDs(red, on);
    
82.     DAC->SR &= ~(1<<13);
    
83.   }
    
84. }
    

复制代码

ADC

12位ADC是一种逐次逼近型模拟数字转换器。它有多达19个通道，可测量16个外部和2个内部信号源和Vbat通道。各通道的A/D转换可以单次、连续、扫描或间断模式执行。ADC的结果可以左对齐或右对齐方式存储在16位数据寄存器中。

模拟看门狗特性允许应用程序检测输入电压是否超出用户定义的高/低阀值。

有16个多路通道。

通道选择：

      可以把转换组织成两组：规则组和注入组。在任意多个通道上以任意顺序进行的一系列转换构成成组转换。例如，可以如下顺序完成转换：通道3、通道8、通道2、通道2、通道0、通道2、通道2、通道15。

      规则组由多达16个转换组成。规则通道和它们的转换顺序在ADC_SQRx寄存器中选择。规则组中转换的总数应写入ADC_SQR1寄存器的L[3:0]位中。

       注入组由多达4个转换组成。注入通道和它们的转换顺序在ADC_JSQR寄存器中选择。注入组里的转换总数目应写入ADC_JSQR寄存器的L[1:0]位中。如果ADC_SQRx或ADC_JSQR寄存器在转换期间被更改，当前的转换被清除，一个新的启动脉冲将发送到ADC以转换新选择的组。

单次转换模式：

        单次转换模式下，ADC只执行一次转换。该模式既可通过设置ADC_CR2寄存器的ADON位(只适用于规则通道)启动也可通过外部触发启动(适用于规则通道或注入通道)，这时CONT位为0。

一旦选择通道的转换完成：

如果一个规则通道被转换：

─ 转换数据被储存在16位ADC_DR寄存器中

─ EOC(转换结束)标志被设置 ─ 如果设置了EOCIE，则产生中断。

如果一个注入通道被转换：

─ 转换数据被储存在16位的ADC_DRJ1寄存器中

─ JEOC(注入转换结束)标志被设置 ─ 如果设置了JEOCIE位，则产生中断。

然后ADC停止

连续转换模式：

        在连续转换模式中，当前面ADC转换一结束马上就启动另一次转换。此模式可通过外部触发启动或通过设置ADC_CR2寄存器上的ADON位启动，此时CONT位是1。

每个转换后：

如果一个规则通道被转换：

─ 转换数据被储存在16位的ADC_DR寄存器中

─ EOC(转换结束)标志被设置

─ 如果设置了EOCIE，则产生中断。

注入通道不能被用于连续转换模式，唯一的例外是当规则通道配置为连续转换后，注入通道配置为自动转换。

扫描模式：

         此模式用来扫描一组模拟通道。

         扫描模式可通过设置ADC_CR1寄存器的SCAN位来选择。一旦这个位被设置，ADC扫描所有被ADC_SQRX寄存器(对规则通道)或ADC_JSQR(对注入通道)选中的所有通道。在每个组的每个通道上执行单次转换。在每个转换结束时，同一组的下一个通道被自动转换。如果设置了CONT位，转换不会在选择组的最后一个通道上停止，而是再次从选择组的第一个通道继续转换。

如果设置了DMA位，在每次EOC后，DMA控制器把规则组通道的转换数据传输到SRAM中。而注入通道转换的数据总是存储在ADC_JDRx寄存器中。

在以下情况中，ADC_SR寄存器的EOC位将被设置：
在每个规则组序列结束后，如果EOCS位被清0
在每个规则通道转换结束，如果EOCS位设置为1
注入通道转换结束数据总是存放在ADC_JDRx寄存器中

注入通道管理：

触发注入

清除ADC_CR1寄存器的JAUTO位，并且设置SCAN位，即可使用触发注入功能。

1. 利用外部触发或通过设置ADC_CR2寄存器的ADON位，启动一组规则通道的转换。

2. 如果在规则通道转换期间产生一外部注入触发或者JSWSTART位被设置，当前转换被复位，注入通道序列被以单次扫描方式进行转换。

3. 然后，恢复上次被中断的规则组通道转换。如果在注入转换期间产生一规则事件，注入转换不会被中断，但是规则序列将在注入序列结束后被执行。

注：当使用触发的注入转换时，必须保证触发事件的间隔长于注入序列。例如：序列长度为30个ADC时钟周期(即2个具有3个时钟间隔采样时间的转换)，触发之间最小的间隔必须是31个ADC时钟周期。

自动注入

如果设置了JAUTO位，在规则组通道之后，注入组通道被自动转换。这可以用来转换在ADC_SQRx和ADC_JSQR寄存器中设置的多至20个转换序列。

在此模式里，必须禁止注入通道的外部触发。

如果除JAUTO位外还设置了CONT位，规则通道至注入通道的转换序列被连续执行。

间断模式：

规则组

此模式通过设置ADC_CR1寄存器上的DISCEN位激活。它可以用来执行一个短序列的n次转换(n<=8)，此转换是ADC_SQRx寄存器所选择的转换序列的一部分。数值n由ADC_CR1寄存器的DISCNUM[2:0]位给出。

一个外部触发信号可以启动ADC_SQRx寄存器中描述的下一轮n次转换，直到此序列所有的转换完成为止。总的序列长度由ADC_SQR1寄存器的L[3:0]定义。

例如：

n=3，被转换的通道 = 0、1、2、3、6、7、9、10

第一次触发：转换的序列为 0、1、2

第二次触发：转换的序列为 3、6、7

第三次触发：转换的序列为 9、10，并产生EOC事件

第四次触发：转换的序列 0、1、2

注： 当以间断模式转换一个规则组时，转换序列结束后不自动从头开始。 当所有子组被转换完成，下一次触发启动第一个子组的转换。在上面的例子中，第四次触发重新转换第一子组的通道0、1和2

注入组

此模式通过设置ADC_CR1寄存器的JDISCEN位激活。在一个外部触发事件后，该模式按通道顺序逐个转换ADC_JSQR寄存器中选择的序列。

一个外部触发信号可以启动ADC_JSQR寄存器选择的下一个通道序列的转换，直到序列中所有的转换完成为止。总的序列长度由ADC_JSQR寄存器的JL[1:0]位定义。

例如： n=1，被转换的通道 = 1、2、3

第一次触发：通道1被转换

第二次触发：通道2被转换

第三次触发：通道3被转换，并且产生EOC和JEOC事件

第四次触发：通道1被转换

设置步骤：

1． 配置相关输入通道的IO口。

2． 设置DMA

3． 如果双重ADC或三重采样，设置ADC的公共寄存器

4． 配置要使用到的ADC

程序：

1. /************************************
   
2.     标题：一个ADC连续采样
   
3.     软件平台：IAR for ARM6.21
   
4.     硬件平台：stm32f4-discovery
   
5.     主频：168M
   
6.    
   
7.     author：小船
   
8.     data：2012-02-14
   
9. *************************************/
   
10. 
    
11. #include <stm32f4xx.h>
    
12. #include "MyDebugger.h"
    
13. 
    
14. __IO uint16_t ADC3ConvertedVault[10000];
    
15. char TXbuffer[] = "PC1输入电压为:x.xxxV\n\r";
    
16. 
    
17. void ADC3_IN11_Config(void);
    
18. 
    
19. void main ()
    
20. {   
    
21.   SCB->AIRCR = 0x05FA0000 | 0x400;  //中断优先级分组 抢占：响应=3:1
    
22. 
    
23.   ADC3_IN11_Config();
    
24.    
    
25.   MyDebugger_Init();
    
26. 
    
27.   while(1)
    
28.   {
    
29.   };
    
30. }
    
31. 
    
32. void ADC3_IN11_Config(void)
    
33. {
    
34.     /***GPIO设置***/
    
35.   RCC->AHB1ENR |= (1<<2); //打开GPIOC时钟
    
36.   GPIOC->MODER &= 0xfffffff3;//PC1模拟模式
    
37.   GPIOC->MODER |= 0x0000000C;
    
38.   GPIOC->PUPDR &= 0xfffffff3;//无上拉无下拉   
    
39. 
    
40.   /***DMA设置***/
    
41.   RCC->AHB1ENR |= (1<<22); //使能DMA2时钟
    
42.   ADC3->CR2 &= ~(1<<8);//ADC3 dma发送模式除能
    
43.   DMA2_Stream0->CR &= 0xFFFFFFFE; //除能DMA2_Stream0
    
44.   while(DMA2_Stream0->CR & 0x00000001);//确保DMA可以被设置
    
45.   DMA2->LIFCR |= 0x0000003D;//传送前清空DMA1_Stream5所有中断标志
    
46.   DMA2_Stream0->PAR = (uint32_t)&ADC3->DR;//设置外设地址
    
47.   DMA2_Stream0->M0AR = (uint32_t)ADC3ConvertedVault; //设置内存地址
    
48.   DMA2_Stream0->CR |= 0x0002800;//16位数据
    
49.   DMA2_Stream0->NDTR = 10000; //设置dma传输数据的数量
    
50.   /*
    
51.     设置dma2通道2，即ADC3
    
52.     优先级Medium
    
53.     传输方向外设到内存
    
54.     内存递增模式
    
55.     循环模式
    
56.     传输完成中断
    
57.   */
    
58.   DMA2_Stream0->CR |= ( 0x04000000 | 0x00010000 | 0x0
    
59.                         | (1<<10) | (1<<8) | (1<<4) );
    
60.   
    
61.   NVIC->IP[56] = 0xB0;
    
62.   NVIC->ISER[1] |= (1<<(56-32));
    
63.   
    
64.   DMA2_Stream0->CR |= 1; //DMA2数据流0使能
    
65.   
    
66.   /***ADC3设置***/
    
67.   RCC->APB2ENR |= (1<<10); //使能ADC3时钟
    
68.   ADC3->SQR1 = 0x00000000;//转换一个通道
    
69.   ADC3->SQR3 = 0x0000000B;//第一个通道为ADC3_in11
    
70.   ADC3->CR1 &= 0x00000000;
    
71.   ADC3->CR2 &= 0x00000000;  
    
72.   ADC3->CR2 |= (1<<1);  //连续转换
    
73.   ADC3->CR2 |= (1<<9); //最后一次ADC转换后发出dma请求
    
74.   ADC3->CR2 |= (1<<0);   //开启AD转换
    
75.   
    
76.   ADC3->CR2 |= (1<<8);//ADC dma发送模式使能
    
77.   
    
78.   ADC3->CR2 |= (1<<30); //规则通道转换开始
    
79. }
    
80. 
    
81. void DMA2_Stream0_IRQHandler (void)
    
82. {
    
83.   uint32_t i;
    
84.   uint32_t Average;
    
85.   if(DMA2->LISR & 0x00000010)
    
86.   {
    
87.       DMA2->LIFCR |= 0x00000010;
    
88.       for(i = 0; i < 10000; i++)  // 对一万个数据取平均值
    
89.         Average += ADC3ConvertedVault[i];
    
90.       Average *= 3;
    
91.       Average /= 40960;
    
92.       TXbuffer[14] = ( Average / 1000 ) % 10 + 0x30;//转换成ASCII码
    
93.       TXbuffer[16] = ( Average / 100 ) % 10 + 0x30;
    
94.       TXbuffer[17] = ( Average / 10 ) % 10 + 0x30;
    
95.       TXbuffer[18] = Average % 10 + 0x30;
    
96.       MyDebugger_Message(TXbuffer, sizeof(TXbuffer)/sizeof(char));  
    
97.   }
    
98. }
    
99. 
    

复制代码

运行结果：

三ADC交替采样

在多ADC模式中，ADC1为主，ADC2或ADC3为从，交替或者同时触发，工作模式取决于ADC_CCR寄存器的MULTI[4:0]。

       多ADC模式中，转换后的数据可以多模式的数据寄存器（ADC_CDR）中读取。状态可以在多模式的状态寄存器（ADC_CSR）读取。

        

多ADC模式下的DMA传输方式：

    方式1：每个AD转换完都发出DMA请求，多模式的数据寄存器（ADC_CDR）用低位保存转换结果。

1st request: ADC_CDR[31:0] = ADC1_DR[15:0]

2nd request: ADC_CDR[31:0] = ADC2_DR[15:0]

3rd request: ADC_CDR[31:0] = ADC3_DR[15:0]

4th request: ADC_CDR[31:0] = ADC1_DR[15:0]

方式2：每两个AD转换完都发出DMA请求。

双ADC模式：

高十六位保存ADC2结果，低十六位保存ADC1结果

1st request: ADC_CDR[31:0] = ADC2_DR[15:0] |ADC1_DR[15:0]

2nd request: ADC_CDR[31:0] = ADC2_DR[15:0] |ADC1_DR[15:0]

三ADC模式：

1st request: ADC_CDR[31:0] = ADC2_DR[15:0] |ADC1_DR[15:0]

2nd request: ADC_CDR[31:0] = ADC1_DR[15:0] |ADC3_DR[15:0]

3rd request: ADC_CDR[31:0] = ADC3_DR[15:0] |ADC2_DR[15:0]

4th request: ADC_CDR[31:0] = ADC2_DR[15:0] |ADC1_DR[15:0]

方式2：每两个AD转换完都发出DMA请求。与方式2相似，但是DMA以半字方式传输。

用于6位或者8位分辨率中。

双ADC模式：

高8位保存ADC2结果，低8位保存ADC1结果

1st request: ADC_CDR[15:0] = ADC2_DR[7:0] | ADC1_DR[7:0]

2nd request: ADC_CDR[15:0] = ADC2_DR[7:0] | ADC1_DR[7:0]

三ADC模式：

1st request: ADC_CDR[15:0] = ADC2_DR[7:0] | ADC1_DR[7:0]

2nd request: ADC_CDR[15:0] = ADC1_DR[7:0] | ADC3_DR[7:0]

3rd request: ADC_CDR[15:0] = ADC3_DR[7:0] | ADC2_DR[7:0]

4th request: ADC_CDR[15:0] = ADC2_DR[7:0] | ADC1_DR[7:0]

多ADC转换模式：

1.     注入同步模式

2.     规则同步模式

3.     交替模式

4.     交替触发模式

5.     规则同步+注入同步模式

6.     规则同步+交替触发模式

交替模式配置步骤：

1． 配置相关输入通道的IO口。

2． 设置DMA

3． 如果双重ADC或三重采样，设置ADC的公共寄存器

       a.     设置公共寄存器首先要打开任意一个ADC的时钟，否则这部分数字电路是没有开始工作的。

        b.     设置DMA模式

        c.     设置ADC转换完成后，发送DMA请求

        d.     设置多ADC模式

        e.     设置两次采样间隔周期

4． 配置要使用到的ADC（必须ADC1为主，其他为从）。

程序：

1. /************************************
   
2.     标题：ADC
   
3.     软件平台：IAR for ARM6.21
   
4.     硬件平台：stm32f4-discovery
   
5.     主频：168M
   
6.    
   
7.     author：小船
   
8.     data：2012-02-16
   
9. *************************************/
   
10. 
    
11. #include <stm32f4xx.h>
    
12. #include "MyDebugger.h"
    
13. 
    
14. __IO uint16_t ADCConvertedVault[10000];
    
15. char TXbuffer[] = "PC1输入电压为:x.xxxV\n\r";
    
16. 
    
17. void ADC_IO_Config(void);
    
18. void ADC_DMA_Config(void);
    
19. 
    
20. void ADC_Common_Config(void);
    
21. 
    
22. void ADC3_IN11_Config(void);
    
23. void ADC2_IN11_Config(void);
    
24. void ADC1_IN11_Config(void);
    
25. 
    
26. void main ()
    
27. {   
    
28.   SCB->AIRCR = 0x05FA0000 | 0x400;  //中断优先级分组 抢占：响应=3:1
    
29. 
    
30.   ADC_IO_Config();
    
31.   ADC_DMA_Config();
    
32.   
    
33.   ADC_Common_Config();
    
34.   
    
35.   ADC3_IN11_Config();
    
36.   ADC2_IN11_Config();
    
37.   ADC1_IN11_Config();
    
38.   
    
39.   ADC3->CR2 |= (1<<0);   //开启ADC3转换
    
40.   ADC2->CR2 |= (1<<0);   //开启ADC2转换
    
41.   ADC1->CR2 |= (1<<0);   //开启ADC1转换
    
42.    
    
43.   ADC1->CR2 |= (1<<30); //触发转换开始
    
44.   
    
45.   MyDebugger_Init();
    
46. 
    
47.   while(1)
    
48.   {
    
49.   };
    
50. }
    
51. 
    
52. void ADC_Common_Config(void)
    
53. {
    
54.   RCC->APB2ENR |= ( (1<<8) | (1<<9) | (1<<10) ); //使能ADC时钟
    
55.   ADC->CCR &= 0x00000000;
    
56.   
    
57.   /*
    
58.   DMA模式1
    
59.   最后一次ADC转换后发出dma请求
    
60.   交错模式
    
61.   2次采样之间的延迟5个周期
    
62.   */
    
63.   ADC->CCR |= ( 0x00004000 | (1<<13) | 0x00000017 | 0x00000000);
    
64.    
    
65. }
    
66. 
    
67. /***ADC1设置***/
    
68. void ADC1_IN11_Config(void)
    
69. {   
    
70.   ADC1->SQR1 = 0x00000000;//转换一个通道
    
71.   ADC1->SQR3 = 0x0000000B;//第一个通道为ADC1_in11
    
72.   ADC1->CR1 &= 0x00000000;
    
73.   ADC1->CR2 &= 0x00000000;  
    
74.   ADC1->CR2 |= (1<<1);  //连续转换
    
75.   ADC1->CR2 |= (1<<9); //最后一次ADC转换后发出dma请求
    
76. 
    
77.   ADC1->CR2 |= (1<<8);//ADC dma发送模式使能
    
78. }
    
79. 
    
80. /***ADC2设置***/
    
81. void ADC2_IN11_Config(void)
    
82. {   
    
83.   ADC2->SQR1 = 0x00000000;//转换一个通道
    
84.   ADC2->SQR3 = 0x0000000B;//第一个通道为ADC1_in11
    
85.   ADC2->CR1 &= 0x00000000;
    
86.   ADC2->CR2 &= 0x00000000;  
    
87.   ADC2->CR2 |= (1<<1);  //连续转换
    
88.   ADC2->CR2 |= (1<<9); //最后一次ADC转换后发出dma请求
    
89. }
    
90. 
    
91. /***ADC3设置***/
    
92. void ADC3_IN11_Config(void)
    
93. {   
    
94.   ADC3->SQR1 = 0x00000000;//转换一个通道
    
95.   ADC3->SQR3 = 0x0000000B;//第一个通道为ADC3_in11
    
96.   ADC3->CR1 &= 0x00000000;
    
97.   ADC3->CR2 &= 0x00000000;  
    
98.   ADC3->CR2 |= (1<<1);  //连续转换
    
99.   ADC3->CR2 |= (1<<9); //最后一次ADC转换后发出dma请求
    
100. }
     
101. 
     
102. /***GPIO设置***/
     
103. void ADC_IO_Config(void)
     
104. {
     
105.   RCC->AHB1ENR |= (1<<2); //打开GPIOC时钟
     
106.   GPIOC->MODER &= 0xfffffff3;//PC1模拟模式
     
107.   GPIOC->MODER |= 0x0000000C;
     
108.   GPIOC->PUPDR &= 0xfffffff3;//无上拉无下拉  
     
109. }
     
110. 
     
111. /***DMA设置***/
     
112. void ADC_DMA_Config(void)
     
113. {   
     
114.   RCC->AHB1ENR |= (1<<22); //使能DMA2时钟
     
115.   ADC3->CR2 &= ~(1<<8);//ADC3 dma发送模式除能
     
116.   DMA2_Stream0->CR &= 0xFFFFFFFE; //除能DMA2_Stream0
     
117.   while(DMA2_Stream0->CR & 0x00000001);//确保DMA可以被设置
     
118.   DMA2->LIFCR |= 0x0000003D;//传送前清空DMA2_Stream0所有中断标志
     
119.   DMA2_Stream0->PAR = (uint32_t)&ADC->CDR;//设置外设地址
     
120.   DMA2_Stream0->M0AR = (uint32_t)ADCConvertedVault; //设置内存地址
     
121.   DMA2_Stream0->CR |= 0x0002800;//16位数据
     
122.   DMA2_Stream0->NDTR = 10000; //设置dma传输数据的数量
     
123.   /*
     
124.     设置dma2通道0，即ADC1
     
125.     优先级Medium
     
126.     传输方向外设到内存
     
127.     内存递增模式
     
128.     循环模式
     
129.     传输完成中断
     
130.   */
     
131.   DMA2_Stream0->CR |= ( 0x00000000 | 0x00010000 | 0x0 | (1<<10) | (1<<8) | (1<<4) );
     
132.   
     
133.   NVIC->IP[56] = 0xB0;
     
134.   NVIC->ISER[1] |= (1<<(56-32));
     
135.   
     
136.   DMA2_Stream0->CR |= 1; //DMA2数据流0使能
     
137. }
     
138. 
     
139. void DMA2_Stream0_IRQHandler (void)
     
140. {
     
141.   uint32_t i;
     
142.   uint32_t Average;
     
143.   if(DMA2->LISR & 0x00000010)
     
144.   {
     
145.       DMA2->LIFCR |= 0x00000010;
     
146.       for(i = 0; i < 10000; i++)  // 对一万个数据取平均值
     
147.         Average += ADCConvertedVault[i];
     
148.       Average *= 3;
     
149.       Average /= 40960;
     
150.       TXbuffer[14] = ( Average / 1000 ) % 10 + 0x30;//转换成ASCII码
     
151.       TXbuffer[16] = ( Average / 100 ) % 10 + 0x30;
     
152.       TXbuffer[17] = ( Average / 10 ) % 10 + 0x30;
     
153.       TXbuffer[18] = Average % 10 + 0x30;
     
154.       MyDebugger_Message(TXbuffer, sizeof(TXbuffer)/sizeof(char));  
     
155.   }
     
156. }
     
157. 
     

复制代码

运行结果：

GY@艳

{:soso_e127:}真是苦了奋斗哥了。

奋斗哥

数字滤波

      为了对stm32f4的ADC和DAC有更多的了解，我决定做一个实用性比较强的实验。就是数字滤波实验，利用stm32f4的DAC可以产生噪声的特点，利用它的一路DAC产生叠加噪声的信号作为原始信号。然后用ADC测量，把结果经过滤波处理后用DAC的另一通道把结果输出，用双踪示波器观察。

一阶惯性滤波器及其数字化

一阶惯性滤波器的传递函数为：

利用一阶差分法离散化，可以得到一阶惯性数字滤波算法：

其中T为采样周期，为滤波时间常数。T和必须根据信号频谱来选择。

编程实现：

a.     设定一个1024点正弦波表，用DAC1叠加噪声输出

b.     配置定时器6更新频率为1M

c.     DAC的时钟为TIM6更新事件，1024点，频率大概为0.5M

d.     在TIM6的更新中断中启动一次AD转换

e.     AD转换中断中做滤波处理，然后把数值送DAC2，启动一次DAC2

程序：

1. /************************************
   
2.     标题：数字滤波实验
   
3.     软件平台：IAR for ARM6.21
   
4.     硬件平台：stm32f4-discovery
   
5.     主频：168M
   
6. 
   
7.     描述：用DAC1产生一路叠加了噪声的信号
   
8.           用ADC通道11测量上面产生的信号
   
9.           对ADC的测量结果进行滤波处理
   
10.           用DAC2把滤波后的结果输出
    
11.    
    
12.     author：小船
    
13.     data：2012-02-17
    
14. *************************************/
    
15. 
    
16. #include <stm32f4xx.h>
    
17. #include "MyDebugger.h"
    
18. #include "sintable.h"
    
19. 
    
20. /*********变量声明********/
    
21. uint16_t Y0, Y1;//滤波器输出值
    
22. float T = 0.000001;//采样周期
    
23. float C = 0.00003; //滤波常数
    
24. 
    
25. /*********函数声明********/
    
26. void timer6_Init(void);
    
27. void ADC3_IN11_Config(void);
    
28. void DAC_channel2_Config(void);
    
29. void Generate_SinSignal_with_Noise(void);
    
30. 
    
31. void main ()
    
32. {   
    
33. 
    
34.   SCB->AIRCR = 0x05FA0000 | 0x400;  //中断优先级分组 抢占：响应=3:1
    
35. 
    
36.   MyDebugger_Init();
    
37. 
    
38.   ADC3_IN11_Config();
    
39.   Generate_SinSignal_with_Noise();
    
40.   DAC_channel2_Config();  
    
41.   timer6_Init();
    
42. 
    
43.   while(1)
    
44.   {
    
45.   };
    
46. }
    
47. 
    
48. /**************************************
    
49.   函数名：timer6_Init
    
50.   参数：无
    
51.   返回值：无
    
52.   功能：设置定时器6更新频率为1M
    
53.         定时器6更新事件为DAC1、2时钟
    
54.         更新中断启动ADC检测
    
55. **************************************/
    
56. void timer6_Init(void)
    
57. {
    
58.   /***定时器设置***/
    
59.   RCC->APB1ENR |= (1<<4);//打开TIM6时钟
    
60.   TIM6->PSC = 0;
    
61.   TIM6->ARR = 83;  //使得更新事件频率为1m
    
62.   TIM6->CR2 |=  0x00000020;//更新事件输出
    
63.   TIM6->DIER |= 1; //使能中断
    
64.   TIM6->CR1 |= 1; //开始计时
    
65. }
    
66. 
    
67. /**************************************
    
68.   函数名：Generate_SinSignal_with_Noise
    
69.   参数：无
    
70.   返回值：无
    
71.   功能：用DAC1产生一路叠加了噪声的信号
    
72. ***************************************/
    
73. void Generate_SinSignal_with_Noise(void)
    
74. {
    
75.   /***GPIO设置***/
    
76.   RCC->AHB1ENR |= (1<<0); //打开GPIOA时钟
    
77.   GPIOA->MODER |= 0x00000F00;//PA4、5模拟模式
    
78.   GPIOA->PUPDR &= 0xfffff0ff;//无上拉无下拉   
    
79.   
    
80.   /***DAC设置***/
    
81.   RCC->APB1ENR |= (1<<29); //使能DAC时钟
    
82.   DAC->CR &= 0xffff0000;
    
83.   /*
    
84.   使能DMA堵塞中断
    
85.   使能通道1触发
    
86.   叠加噪声
    
87.   */
    
88.   DAC->CR |= ( (1<<13) | (1<<2) | 0x00000040 | 0x00000800);  
    
89.   NVIC->IP[54] = 0xA0;
    
90.   NVIC->ISER[1] |= (1<<(54-32));
    
91. 
    
92.   /***DMA设置***/
    
93.   RCC->AHB1ENR |= (1<<21); //使能DMA1时钟
    
94.   DAC->CR &= ~(1<<12);//DAC dma发送模式除能
    
95.   DMA1_Stream5->CR &= 0xFFFFFFFE; //除能DMA1_Stream5
    
96.   while(DMA1_Stream5->CR & 0x00000001);//确保DMA可以被设置
    
97.   DMA1->HIFCR |= 0x000004f0;//传送前清空DMA1_Stream5所有中断标志
    
98.   DMA1_Stream5->PAR = (uint32_t)&DAC->DHR12R1;//设置外设地址
    
99.   DMA1_Stream5->M0AR = (uint32_t)SinTable; //设置内存地址
    
100.   DMA1_Stream5->CR |= 0x0002800;//16位数据
     
101.   DMA1_Stream5->NDTR = 1024; //设置dma传输数据的数量
     
102.   /*
     
103.     设置dma通道7，即DAC1
     
104.     优先级Medium
     
105.     传输方向内存到外设
     
106.     内存递增模式
     
107.     循环模式
     
108.   */
     
109.   DMA1_Stream5->CR |= ( 0x0e000000 | 0x00010000 | (1<<6)
     
110.                         | (1<<10) | (1<<8) );
     
111.   
     
112.   DMA1_Stream5->CR |= 1; //DMA数据流5使能
     
113.   
     
114.   DAC->CR |= (1<<0);   //DAC通道1使能
     
115. 
     
116.   DAC->CR |= (1<<12);//DAC dma发送模式使能
     
117. }
     
118. 
     
119. /**************************************
     
120.   函数名：ADC3_IN11_Config
     
121.   参数：无
     
122.   返回值：无
     
123.   功能：用ADC通道11测量上面产生的信号
     
124. ***************************************/
     
125. void ADC3_IN11_Config(void)
     
126. {
     
127.     /***GPIO设置***/
     
128.   RCC->AHB1ENR |= (1<<2); //打开GPIOC时钟
     
129.   GPIOC->MODER &= 0xfffffff3;//PC1模拟模式
     
130.   GPIOC->MODER |= 0x0000000C;
     
131.   GPIOC->PUPDR &= 0xfffffff3;//无上拉无下拉   
     
132.   
     
133.   /***ADC3设置***/
     
134.   RCC->APB2ENR |= (1<<10); //使能ADC3时钟
     
135.   ADC3->SQR1 = 0x00000000;//转换一个通道
     
136.   ADC3->SQR3 = 0x0000000B;//第一个通道为ADC3_in11
     
137.   ADC3->CR1 &= 0x00000000;
     
138.   ADC3->CR2 &= 0x00000000;  
     
139. //单次转换
     
140.   ADC3->CR1 |= (1<<5);//使能转换完成中断
     
141.   NVIC->IP[18] = 0xc0;
     
142.   NVIC->ISER[0] |= (1<<18);
     
143. }
     
144. 
     
145. /**************************************
     
146.   函数名：DAC_channel2_Config
     
147.   参数：无
     
148.   返回值：无
     
149.   功能：用DAC2把滤波后的结果输出
     
150. ***************************************/
     
151. void DAC_channel2_Config(void)
     
152. {
     
153.   /***DAC设置***/
     
154.   RCC->APB1ENR |= (1<<29); //使能DAC时钟
     
155.   DAC->CR &= 0x0000ffff;
     
156.   /*
     
157.   使能通道2触发
     
158.   配置为软件触发
     
159.   */
     
160.   DAC->CR |= ( (1<<18) | (0x00380000) );
     
161.   
     
162.   DAC->CR |= (1<<16);   //DAC通道2使能
     
163. }
     
164. 
     
165. void TIM6_DAC_IRQHandler(void)
     
166. {
     
167.   if( DAC->SR & (1<<13) )
     
168.   {
     
169.     MyDebugger_LEDs(red, on);//亮红灯指示DAC1的DMA传输数据错误
     
170.     DAC->SR &= ~(1<<13);
     
171.   }
     
172.   
     
173.   if(TIM6->SR)
     
174.   {   
     
175.     ADC3->CR2 |= (1<<0);   //开启AD转换  
     
176.     ADC3->CR2 |= (1<<30); //规则通道转换开始
     
177.    
     
178.     TIM6->SR &= ~(0x0001);
     
179.   }
     
180. }
     
181. 
     
182. void ADC_IRQHandler(void)
     
183. {
     
184.   if( ADC3->SR & (1<<1))
     
185.   {
     
186.     Y0 = (uint16_t)( (float)(( T / C ) * ADC3->DR) //滤波公式
     
187.                       + (float)(( 1 - T / C ) * Y1) );
     
188.     Y1 = Y0;
     
189.     DAC->DHR12R2 = Y0;  //DAC2输出滤波后的结果
     
190.     DAC->SWTRIGR |= (1<<1);
     
191.    
     
192.     ADC3->SR &= ~(1<<1);
     
193.   }
     
194. }
     
195. 
     

复制代码

输出的信号：

用AD测量后不经过滤波直接输出：

经过滤波的输出：


结论：经过滤波后，很好地把噪声滤除了，但相位有一定的滞后，幅值会变小。

CAN控制器

首先简单介绍一下CAN总线，关于CAN总线是谁发明的，CAN总线的历史，CAN总线的发展，CAN总线的应用场合，这些，通通不说。这里只是以我个人理解，简单说说CAN通信。CAN总线的端点没有地址（除非自己在帧里定义地址），CAN总线通信不用地址，用标识符，不是单独的谁发给谁，而是，你总是发送给整个网络。然后每个节点都有过滤器，对网络上的传播的帧的标识符进行过滤，自己想要什么样的帧，可以设置自己的过滤器，接收相关的帧信息。如果两个节点同时发送怎么办？这个不用我们担心，CAN控制器会自己仲裁，让高优先级的帧先发。

         然后我们可以了解一下stm32的CAN控制器。

         如上图所示，stm32有两个can控制器，can1（主），和can2（从），其中过滤器的设置是通过can1来设置，其他工作模式，波特率等，可以各自设置。每个控制器有三个发送邮箱，两个fifo，每个fifo有三个接收邮箱。

         发送：选择一个空的发送邮箱，把帧信息写到该发送邮箱的寄存器里，请求发送，控制器就会根据标识符的优先级把帧先后发送出去。

         接收：如果接收到的帧的标识符能过过滤表的一系列过滤，该帧信息就会保存在fifo接收邮箱的寄存器里。

         过滤器：stm32f407共有28组过滤器，每组过滤器可以设置关联到fifo0或者fifo1，每组都包括两个32位存储器，可以配置成一个32位有位屏蔽功能的标识符过滤器，或者两个32位完全匹配的标识符过滤器，或者两个16位有位屏蔽功能的标识符过滤器，或者四个16位完全匹配的标识符过滤器。如下图所示：

我所说的完全匹配的意思是，接收到的帧的标识符每一位都要跟过滤器对应的位一样，才能过得了这个过滤器。有位屏蔽功能的意思是一个寄存器放标识符，一个放屏蔽掩码，屏蔽掩码为1的位对应的接收到的帧的标识符的位与对应的放标识符的寄存器的位一致，就能通过。

传输一位的时间和波特率的计算：

         CAN控制器的波特率是由APB时钟线和CAN位时序寄存器CAN_BTR的TS2[3：0]、TS1[2:0]和BRP[9：0]确定的，其中，TS1[2：0]定义了时间段1占用多少个时间单元，TS2[3：0]定义了时间段2占用多少个时间单元，BRP[9：0]定义对APB1时钟的分频。

PS：设置波特率为1M

其中Tpclk为APB1的时钟周期，假设为

Tpclk = 1/42M

0≦TS1≦7

0≦TS2≦15

0≦BRP≦1021

根据以上数据，有

(TS2+TS1+3)(BRP+1)=42

令BRP=2，有

TS2+TS1=11

令TS1=8，TS2=3

设置步骤：

1.     设置中断优先级分组（如果之前没有设置），这个最好一个程序里只在开头设置一次。

2.     使能相关GPIO时钟。

3.     选择相关GPIO引脚的复用功能。

4.     设置相关GPIO引脚为复用模式。

5.     设置相关GPIO引脚的速度，方式。

6.     设置主控制寄存器MCR，进入初始化模式

7.     等待进入初始化模式

8.     设置波特率。

9.     其他设置。

10.  如果要用到中断，在中断使能寄存器IER中使能相关中断响应。

11.  如果要用到中断，设置相关中断优先级（NVIC_IP）。

12.  如果要用到中断，使能相关中断（NVIC_ISER）。

13.  设置主控制寄存器MCR，进入正常工作模式。

14.  设置FMR，使过滤器组工作在初始化模式。

15.  设置FMR的CAN2SB，确定CAN2的过滤器组从哪一组开始。

16.  设置用到的过滤器组的工作方式。

17.  设置用到的过滤器组的位宽。

18.  给fifo0和fifo2划分（关联）过滤组。

19.  禁用用到的过滤器组。

20.  设置过滤器组的标识符，帧类型等。

21.  使能相关过滤器组。

22.  设置FMR，使过滤器组工作在正常模式。

23.  如果要用中断，编写中断服务函数（函数名是固定的）。

24.  中断服务函数里检查是哪个中断。

25.  编写相应服务程序。

---

电路请参见：小工具之——CAN收发器

有时候调试程序免不了需要一些小电路，以下电路用两个sn65hvd230做了两个CAN总线收发器在同一块板上。

JP1，JP4：两个跳线帽，用于配置终端电阻

JP2，JP3：用于配置波形上升沿斜率

PCB尺寸：33mm*25mm

---

程序：

1. /************************************
   
2.     标题：操作CAN的练习
   
3.     软件平台：IAR for ARM6.21
   
4.     硬件平台：stm32f4-discovery
   
5.     主频：168M
   
6.    
   
7.     描述：通过硬件收发器连接CAN1,CAN2
   
8.           组成一个两个端点的网络
   
9. 
   
10.           CAN1循环发出数据帧
    
11. 
    
12.           CAN2接收过滤数据帧
    
13. 
    
14.           用uart把CAN2接收到
    
15.           的数据帧发到超级终端
    
16. 
    
17.     author：小船
    
18.     data：2012-08-14
    
19. *************************************/
    
20. 
    
21. #include <stm32f4xx.h>
    
22. #include "MyDebugger.h"
    
23. 
    
24. #define RECEIVE_BUFFER_SIZE 20
    
25. 
    
26. u32 CAN2_receive_buffer[RECEIVE_BUFFER_SIZE][4];
    
27. u8 UART_send_buffer[1800];
    
28. u8 Consumer = 0;
    
29. u8 Producer = 0;
    
30. 
    
31. u32 Gb_TimingDelay;
    
32. void Delay(uint32_t nTime);
    
33. void TIM7_init();//定时1s
    
34. u32 get_rece_data();
    
35. void CAN_GPIO_config();
    
36. 
    
37. void main ()
    
38. {   
    
39. 
    
40.   u32 empty_box;
    
41.   SysTick_Config(SystemCoreClock / 1000); //设置systemtick一毫秒中断
    
42.   SCB->AIRCR = 0x05FA0000 | 0x400;  //中断优先级分组 抢占：响应=3:1
    
43. 
    
44.   MyDebugger_Init();
    
45.   TIM7_init();
    
46.   MyDebugger_Message( "\n\rtesting......\n\r" ,
    
47.                      sizeof("\n\rtesting......\n\r")/sizeof(char) );
    
48.   
    
49.   CAN_GPIO_config();
    
50.   
    
51.   RCC->APB1ENR |= ((1<<25)|(1<<26));//使能CAN1、CAN2时钟
    
52.   
    
53.   CAN1->MCR = 0x00000000;
    
54.   /*
    
55.   请求进入初始化模式
    
56.   禁止报文自动重传
    
57.   自动唤醒模式
    
58.   */
    
59.   CAN1->MCR |= ((1<<0)|(1<<4)|(1<<5));
    
60.   CAN1->MCR &= ~(1<<16);//在调试时，CAN照常工作
    
61.   
    
62.   while(!(CAN1->MSR & 0xfffffffe))  //等待进入初始化模式
    
63.   {
    
64.     MyDebugger_LEDs(orange, on);
    
65.   }
    
66.   MyDebugger_LEDs(orange, off);
    
67.   
    
68.   /*
    
69.   正常模式
    
70.   重新同步跳跃宽度（1+1）tq
    
71.   TS2[2:0]=3
    
72.   TS1[3:0]=8
    
73.   BRP[9:0]=2
    
74.   
    
75.   ps：
    
76.   tq = (BRP[9:0] + 1) x tPCLK,
    
77.   tBS2 = tq x (TS2[2:0] + 1),
    
78.   tBS1 = tq x (TS1[3:0] + 1),
    
79.   NominalBitTime = 1 × tq+tBS1+tBS2,
    
80.   BaudRate = 1 / NominalBitTime
    
81.   
    
82.   波特率设为1M
    
83.   */
    
84.   CAN1->BTR = ((0<<30)|(0x01<<24)|(3<<20)|(8<<16)|(2<<0));
    
85.   
    
86.   CAN1->MCR &= ~(0x00000001);//正常工作模式
    
87.   
    
88.   CAN2->MCR = 0x00000000;
    
89.   /*
    
90.   请求进入初始化模式
    
91.   禁止报文自动重传
    
92.   自动唤醒模式
    
93.   */
    
94.   CAN2->MCR |= ((1<<0)|(1<<4)|(1<<5));
    
95.   CAN2->MCR &= ~(1<<16);//在调试时，CAN照常工作
    
96.   
    
97.   while(!(CAN2->MSR & 0xfffffffe))  //等待进入初始化模式
    
98.   {
    
99.     MyDebugger_LEDs(orange, on);
    
100.   }
     
101.   MyDebugger_LEDs(orange, off);
     
102.   
     
103.   /*
     
104.   正常模式
     
105.   重新同步跳跃宽度（1+1）tq
     
106.   TS2[2:0]=3
     
107.   TS1[3:0]=8
     
108.   BRP[9:0]=2
     
109.   
     
110.   ps：
     
111.   tq = (BRP[9:0] + 1) x tPCLK,
     
112.   tBS2 = tq x (TS2[2:0] + 1),
     
113.   tBS1 = tq x (TS1[3:0] + 1),
     
114.   NominalBitTime = 1 × tq+tBS1+tBS2,
     
115.   BaudRate = 1 / NominalBitTime
     
116.   
     
117.   波特率设为1M
     
118.   */
     
119.   CAN2->BTR = ((0<<30)|(0x01<<24)|(3<<20)|(8<<16)|(2<<0));
     
120.   
     
121.   CAN2->IER &= 0x00000000;
     
122.   /*
     
123.   FIFO1消息挂号中断使能
     
124.   FIFO1满中断使能
     
125.   FIFO1溢出中断使能
     
126.   */
     
127.   CAN2->IER |= ((1<<4)|(1<<5)|(1<<6));
     
128.   
     
129.   
     
130.   NVIC->IP[65] = 0xa0;   //抢占优先级101,响应优先级0
     
131.   NVIC->ISER[2] |= (1<<1);  //使能中断线65，也就是can2_rx1中断
     
132.   
     
133.   CAN2->MCR &= ~(0x00000001);//正常工作模式
     
134.   
     
135.   
     
136.   //总共有28组过滤器
     
137.   CAN1->FMR |= 1; //过滤器组工作在初始化模式
     
138.   
     
139.   CAN1->FMR &= 0xffffc0ff;//CAN2的过滤器组从14开始
     
140.   CAN1->FMR |= (14<<8);
     
141.   
     
142.   CAN1->FM1R |= (1<<14);//过滤器组14的寄存器工作在标识符列表模式
     
143.                        
     
144.                         //位宽为16位，2个32位分为四个16位寄存器，过滤四个标识符
     
145.   
     
146.   //CAN1->FS1R |= (1<<15);//过滤器组15为单个32位寄存器，用于扩展标识符
     
147.   
     
148.   CAN1->FFA1R = 0x0fffc000;//0~13号过滤器组关联到fifo0，14~27号过滤器组关联到fifo1
     
149.   
     
150.   CAN1->FA1R &= ~(1<<14);//禁用过滤器组14
     
151.   
     
152.    /*
     
153.   过滤器组0寄存器分为4个十六位过滤器：
     
154.   标识符列表：
     
155.   过滤器编号        匹配标准标识符             RTR       IDE           EXID[17：15]
     
156.      0              0x7cb（111 1100 1011b）    数据帧    标准标识符     000b
     
157.      1              0x4ab（100 1010 1011b）    数据帧    标准标识符     000b
     
158.      2              0x7ab（111 1010 1011b）    数据帧    标准标识符     000b  
     
159.      3              0x40b（100 0000 1011b）    数据帧    标准标识符     000b  
     
160.   */
     
161.   CAN1->sFilterRegister[14].FR1 &= 0x00000000;
     
162.   CAN1->sFilterRegister[14].FR2 &= 0x00000000;
     
163.   CAN1->sFilterRegister[14].FR1 |= ((0x7cb<<5)|(0<<4)|(0<<3));
     
164.   CAN1->sFilterRegister[14].FR1 |= ((0x4ab<<21)|(0<<20)|(0<<19));
     
165.   CAN1->sFilterRegister[14].FR2 |= ((0x7ab<<5)|(0<<4)|(0<<3));
     
166.   CAN1->sFilterRegister[14].FR2 |= ((0x40b<<21)|(0<<20)|(0<<19));
     
167.   
     
168.   CAN1->FA1R |= (1<<14);//使能过滤器组14
     
169.    
     
170.   CAN1->FMR &= ~1; //过滤器组正常工作
     
171.   
     
172.   while(1)
     
173.   {
     
174.     /*
     
175.     选择空的发送邮箱：
     
176.     标准标识符0x7ab（111 1010 1011b）
     
177.     数据帧
     
178.     不使用扩展标识符
     
179.     */
     
180.     if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )
     
181.     {
     
182.       empty_box = ((CAN1->TSR>>24) & 0x00000003);
     
183.       CAN1->sTxMailBox[empty_box].TIR = (0x7ab<<21);  
     
184.       
     
185.       CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;
     
186.       CAN1->sTxMailBox[empty_box].TDTR |= 0x00000008;//发送数据长度为8
     
187.       
     
188.       CAN1->sTxMailBox[empty_box].TDLR = 0x12345678;
     
189.       
     
190.       CAN1->sTxMailBox[empty_box].TDHR = 0x9abcdef0;
     
191.       
     
192.       CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送
     
193.     }
     
194.     else
     
195.     {
     
196.       MyDebugger_LEDs(orange, on);
     
197.     }
     
198.     Delay(100);
     
199.    
     
200.      /*
     
201.     选择空的发送邮箱：
     
202.     标准标识符0x4ab（100 1010 1011b）
     
203.     数据帧
     
204.     不使用扩展标识符
     
205.     */
     
206.     if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )
     
207.     {
     
208.       empty_box = ((CAN1->TSR>>24) & 0x00000003);
     
209.       CAN1->sTxMailBox[empty_box].TIR = (0x4ab<<21);  
     
210.       
     
211.       CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;
     
212.       CAN1->sTxMailBox[empty_box].TDTR |= 0x00000008;//发送数据长度为8
     
213.       
     
214.       CAN1->sTxMailBox[empty_box].TDLR = 0x56781234;
     
215.       
     
216.       CAN1->sTxMailBox[empty_box].TDHR = 0x9abcdef0;
     
217.       
     
218.       CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送
     
219.     }
     
220.     else
     
221.     {
     
222.       MyDebugger_LEDs(orange, on);
     
223.     }
     
224.     Delay(100);
     
225.    
     
226.      /*
     
227.     选择空的发送邮箱：
     
228.     标准标识符0x7cb（100 1010 1011b）
     
229.     数据帧
     
230.     不使用扩展标识符
     
231.     */
     
232.     if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )
     
233.     {
     
234.       empty_box = ((CAN1->TSR>>24) & 0x00000003);
     
235.       CAN1->sTxMailBox[empty_box].TIR = (0x7cb<<21);  
     
236.       
     
237.       CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;
     
238.       CAN1->sTxMailBox[empty_box].TDTR |= 0x00000006;//发送数据长度为6
     
239.       
     
240.       CAN1->sTxMailBox[empty_box].TDLR = 0x56781234;
     
241.       
     
242.       CAN1->sTxMailBox[empty_box].TDHR = 0x00009abc;
     
243.       
     
244.       CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送
     
245.     }
     
246.     else
     
247.     {
     
248.       MyDebugger_LEDs(orange, on);
     
249.     }
     
250.     Delay(100);
     
251.    
     
252.      /*
     
253.     选择空的发送邮箱：
     
254.     标准标识符0x40b（100 0000 1011b）
     
255.     数据帧
     
256.     不使用扩展标识符
     
257.     */
     
258.     if( CAN1->TSR & ((1<<26)|(1<<27)|(1<<28)) )
     
259.     {
     
260.       empty_box = ((CAN1->TSR>>24) & 0x00000003);
     
261.       CAN1->sTxMailBox[empty_box].TIR = (0x40b<<21);  
     
262.       
     
263.       CAN1->sTxMailBox[empty_box].TDTR &= 0xfffffff0;
     
264.       CAN1->sTxMailBox[empty_box].TDTR |= 0x00000004;//发送数据长度为4
     
265.       
     
266.       CAN1->sTxMailBox[empty_box].TDLR = 0x56781234;
     
267.       
     
268.       CAN1->sTxMailBox[empty_box].TDHR = 0x00000000;
     
269.       
     
270.       CAN1->sTxMailBox[empty_box].TIR |= (1<<0);//请求发送
     
271.     }
     
272.     else
     
273.     {
     
274.       MyDebugger_LEDs(orange, on);
     
275.     }
     
276.     Delay(100);
     
277.    
     
278.    }
     
279. }
     
280. 
     
281. /****************************************
     
282.   函数名：CAN_GPIO_config
     
283.   参数：无
     
284.   返回值：无
     
285.   功能：设置CAN1，2控制器用到IO口
     
286.   CAN1_TX---------PD1
     
287.   CAN1_RX---------PB8
     
288.   CAN2_TX---------PB13
     
289.   CAN2_RX---------PB5
     
290. ****************************************/
     
291. void CAN_GPIO_config()
     
292. {
     
293.   RCC->AHB1ENR |= ((1<<1) | (1<<3));//使能GPIOB、D时钟
     
294.   GPIOB->AFR[0] |= 0x00900000;      //AF9
     
295.   GPIOB->AFR[1] |= 0x00900009;
     
296.   GPIOD->AFR[0] |= 0x00000090;
     
297.    
     
298.   GPIOB->MODER &= 0xF3FCF3FF; //第二功能
     
299.   GPIOB->MODER |= 0x08020800;
     
300.   GPIOD->MODER &= 0xFFFFFFF3;
     
301.   GPIOD->MODER |= 0x00000008;
     
302.   
     
303.   GPIOB->OSPEEDR &= 0xF3FCF3FF; //50M
     
304.   GPIOB->OSPEEDR |= 0x08020800;
     
305.   GPIOD->OSPEEDR &= 0xFFFFFFF3;
     
306.   GPIOD->OSPEEDR |= 0x00000008;
     
307.   
     
308.   GPIOB->PUPDR &= 0xF3FCF3FF;   //上拉
     
309.   GPIOB->PUPDR |= 0x04010400;
     
310.   GPIOD->PUPDR &= 0xFFFFFFF3;
     
311.   GPIOD->PUPDR |= 0x00000004;
     
312. }
     
313. 
     
314. /****************************************
     
315.   函数名：CAN2_RX1_IRQHandler
     
316.   参数：无
     
317.   返回值：无
     
318.   功能：CAN2fifo1接收中断处理
     
319.         把信息存进循环队列
     
320. ****************************************/
     
321. void CAN2_RX1_IRQHandler()
     
322. {
     
323.   if(CAN2->RF1R & (0x00000003))//接收到新的消息，fifo1非空
     
324.   {
     
325.     Producer++;
     
326.     if(Producer == RECEIVE_BUFFER_SIZE)Producer = 0;
     
327.     if(Producer != Consumer)
     
328.     {
     
329.       CAN2_receive_buffer[Producer][0] = CAN2->sFIFOMailBox[1].RIR;
     
330.       CAN2_receive_buffer[Producer][1] = CAN2->sFIFOMailBox[1].RDTR;
     
331.       CAN2_receive_buffer[Producer][2] = CAN2->sFIFOMailBox[1].RDLR;
     
332.       CAN2_receive_buffer[Producer][3] = CAN2->sFIFOMailBox[1].RDHR;
     
333.     }
     
334.     else
     
335.     {
     
336.       if(Producer == 0)Producer = RECEIVE_BUFFER_SIZE;
     
337.       Producer--;
     
338.       MyDebugger_LEDs(blue, on);
     
339.     }   
     
340.     CAN2->RF1R |= (1<<5);//释放邮箱
     
341.   }
     
342.   
     
343.   if(CAN2->RF1R & (1<<3))//fifo0满
     
344.   {
     
345.     MyDebugger_LEDs(red, on);
     
346.     CAN2->RF1R &= ~(1<<3);
     
347.   }
     
348.   
     
349.   if(CAN2->RF1R & (1<<4))//fifo0溢出
     
350.   {
     
351.     MyDebugger_LEDs(red, on);
     
352.     CAN2->RF1R &= ~(1<<4);
     
353.   }
     
354. }
     
355. 
     
356. /****************************************
     
357.   函数名：TIM7_init
     
358.   参数：无
     
359.   返回值：无
     
360.   功能：初始化定时器7
     
361.         作1s定时用
     
362. ****************************************/
     
363. void TIM7_init()
     
364. {
     
365.   RCC->APB1ENR |= (1<<5); //打开TIM7时钟
     
366.   TIM7->PSC = 8399; //对时钟84M进行8400分频，使得计数频率为10k
     
367.   TIM7->ARR = 10000;  //定时一秒
     
368.   TIM7->CNT = 0;  //清空计数器
     
369.   TIM7->CR1 |= (1<<7); //自动重装载预装载使能
     
370.   TIM7->DIER |= 1; //使能中断
     
371.   
     
372.   NVIC->IP[55] = 0xe0;
     
373.   NVIC->ISER[1] |= (1<<(55-32));
     
374.   
     
375.   TIM7->CR1 |= 1; //开始计时
     
376. }
     
377. 
     
378. /****************************************
     
379.   函数名：TIM7_IRQHandler
     
380.   参数：无
     
381.   返回值：无
     
382.   功能：定时器7中断处理
     
383.         1s定时到
     
384.         把can2收到的信息转换格式
     
385.         用usrt发送到超级终端显示
     
386. ****************************************/
     
387. void TIM7_IRQHandler(void)
     
388. {
     
389.   u32 length;
     
390.   if(TIM7->SR)
     
391.   {
     
392.     length = get_rece_data();
     
393.     MyDebugger_Message( UART_send_buffer, length );
     
394.     TIM7->SR &= ~(0x0001);
     
395.   }
     
396. }
     
397. 
     
398. /****************************************
     
399.   函数名：get_rece_data
     
400.   参数：无
     
401.   返回值：length 整理后要发送数据的长度
     
402.   功能：把循环队列的信息取出
     
403.         进行格式转换
     
404.         把信息存到uart发送缓冲区
     
405. ****************************************/
     
406. u32 get_rece_data()
     
407. {
     
408.   u8 filter_No;
     
409.   u8 Data_length;
     
410.   char i;
     
411.   u32 length = 0;
     
412.   const char ascii[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
     
413.                           '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
     
414.   while(1)
     
415.   {
     
416.     if(Producer != Consumer)
     
417.       {
     
418.         Consumer++;
     
419.         if(Consumer == RECEIVE_BUFFER_SIZE)Consumer=0;
     
420.         
     
421.         UART_send_buffer[length++] = '\n';
     
422.         UART_send_buffer[length++] = '\r';
     
423.         //Filter No.xx
     
424.         UART_send_buffer[length++] = 'F';
     
425.         UART_send_buffer[length++] = 'i';
     
426.         UART_send_buffer[length++] = 'l';
     
427.         UART_send_buffer[length++] = 't';
     
428.         UART_send_buffer[length++] = 'e';
     
429.         UART_send_buffer[length++] = 'r';
     
430.         UART_send_buffer[length++] = ' ';
     
431.         UART_send_buffer[length++] = 'N';
     
432.         UART_send_buffer[length++] = 'o';
     
433.         UART_send_buffer[length++] = '.';
     
434.    
     
435.         filter_No = (CAN2_receive_buffer[Consumer][1]>>8) & 0x000000ff;
     
436.         UART_send_buffer[length++] = filter_No%100/10 + '0';
     
437.         UART_send_buffer[length++] = filter_No%10 + '0';
     
438.         UART_send_buffer[length++] = '\n';
     
439.         UART_send_buffer[length++] = '\r';
     
440.         
     
441.         //DataLength:x
     
442.         UART_send_buffer[length++] = 'D';
     
443.         UART_send_buffer[length++] = 'a';
     
444.         UART_send_buffer[length++] = 't';
     
445.         UART_send_buffer[length++] = 'a';
     
446.         UART_send_buffer[length++] = 'L';
     
447.         UART_send_buffer[length++] = 'e';
     
448.         UART_send_buffer[length++] = 'n';
     
449.         UART_send_buffer[length++] = 'g';
     
450.         UART_send_buffer[length++] = 't';
     
451.         UART_send_buffer[length++] = 'h';
     
452.         UART_send_buffer[length++] = ':';
     
453.         Data_length = CAN2_receive_buffer[Consumer][1] & 0x0000000f;
     
454.         UART_send_buffer[length++] = Data_length % 10 + '0';
     
455.         UART_send_buffer[length++] = '\n';
     
456.         UART_send_buffer[length++] = '\r';
     
457.         
     
458.         
     
459.         if(CAN2_receive_buffer[Consumer][0] & (1<<1))
     
460.         {
     
461.           UART_send_buffer[length++] = 'R';
     
462.           UART_send_buffer[length++] = 'e';
     
463.           UART_send_buffer[length++] = 'm';
     
464.           UART_send_buffer[length++] = 'o';
     
465.           UART_send_buffer[length++] = 't';
     
466.           UART_send_buffer[length++] = 'e';
     
467.           UART_send_buffer[length++] = 'F';
     
468.           UART_send_buffer[length++] = 'r';
     
469.           UART_send_buffer[length++] = 'a';
     
470.           UART_send_buffer[length++] = 'm';
     
471.           UART_send_buffer[length++] = 'e';
     
472.         }
     
473.         else
     
474.         {
     
475.           UART_send_buffer[length++] = 'D';
     
476.           UART_send_buffer[length++] = 'a';
     
477.           UART_send_buffer[length++] = 't';
     
478.           UART_send_buffer[length++] = 'a';
     
479.           UART_send_buffer[length++] = 'F';
     
480.           UART_send_buffer[length++] = 'r';
     
481.           UART_send_buffer[length++] = 'a';
     
482.           UART_send_buffer[length++] = 'm';
     
483.           UART_send_buffer[length++] = 'e';
     
484.         }
     
485.         UART_send_buffer[length++] = '\n';
     
486.         UART_send_buffer[length++] = '\r';        
     
487.         
     
488.         
     
489.         if(CAN2_receive_buffer[Consumer][0] & (1<<2))
     
490.         {
     
491.           UART_send_buffer[length++] = 'e';
     
492.           UART_send_buffer[length++] = 'x';
     
493.           UART_send_buffer[length++] = 't';
     
494.           UART_send_buffer[length++] = ' ';
     
495.           UART_send_buffer[length++] = 'I';
     
496.           UART_send_buffer[length++] = 'D';
     
497.           UART_send_buffer[length++] = ':';
     
498.          
     
499.           UART_send_buffer[length++] =
     
500.             ascii[CAN2_receive_buffer[Consumer][0] >> 31];
     
501.           UART_send_buffer[length++] =
     
502.             ascii[(CAN2_receive_buffer[Consumer][0] >> 27)& 0x0000000f];
     
503.           UART_send_buffer[length++] =
     
504.             ascii[(CAN2_receive_buffer[Consumer][0] >> 23)& 0x0000000f];
     
505.           UART_send_buffer[length++] =
     
506.             ascii[(CAN2_receive_buffer[Consumer][0] >> 19)& 0x0000000f];
     
507.           UART_send_buffer[length++] =
     
508.             ascii[(CAN2_receive_buffer[Consumer][0] >> 15)& 0x0000000f];
     
509.           UART_send_buffer[length++] =
     
510.             ascii[(CAN2_receive_buffer[Consumer][0] >> 11)& 0x0000000f];
     
511.           UART_send_buffer[length++] =
     
512.             ascii[(CAN2_receive_buffer[Consumer][0] >> 7)& 0x0000000f];
     
513.           UART_send_buffer[length++] =
     
514.             ascii[(CAN2_receive_buffer[Consumer][0] >> 3)& 0x0000000f];
     
515.         }
     
516.         else
     
517.         {
     
518.           UART_send_buffer[length++] = 's';
     
519.           UART_send_buffer[length++] = 't';
     
520.           UART_send_buffer[length++] = 'd';
     
521.           UART_send_buffer[length++] = ' ';
     
522.           UART_send_buffer[length++] = 'I';
     
523.           UART_send_buffer[length++] = 'D';
     
524.           UART_send_buffer[length++] = ':';
     
525.          
     
526.           UART_send_buffer[length++] =
     
527.             ascii[CAN2_receive_buffer[Consumer][0] >> 29];
     
528.           UART_send_buffer[length++] =
     
529.             ascii[(CAN2_receive_buffer[Consumer][0] >> 25)& 0x0000000f];
     
530.           UART_send_buffer[length++] =
     
531.             ascii[(CAN2_receive_buffer[Consumer][0] >> 21)& 0x0000000f];        
     
532.         }
     
533.         UART_send_buffer[length++] = '\n';
     
534.         UART_send_buffer[length++] = '\r';
     
535.         
     
536.         UART_send_buffer[length++] = 'D';
     
537.         UART_send_buffer[length++] = 'a';
     
538.         UART_send_buffer[length++] = 't';
     
539.         UART_send_buffer[length++] = 'a';
     
540.         UART_send_buffer[length++] = ':';
     
541.         if(Data_length > 4)
     
542.         {
     
543.           for(i = 2*Data_length - 8; i > 0; i--)
     
544.             UART_send_buffer[length++] =
     
545.               ascii[(CAN2_receive_buffer[Consumer][3] >> ((i-1)*4))& 0x0000000f];
     
546.          
     
547.           for(i = 8; i > 0; i--)
     
548.             UART_send_buffer[length++] =
     
549.               ascii[(CAN2_receive_buffer[Consumer][2] >> ((i-1)*4))& 0x0000000f];
     
550.         }
     
551.         else
     
552.         {
     
553.           for(i = 2*Data_length; i > 0; i--)
     
554.             UART_send_buffer[length++] =
     
555.               ascii[(CAN2_receive_buffer[Consumer][2] >> ((i-1)*4))& 0x0000000f];         
     
556.         }
     
557.         UART_send_buffer[length++] = '\n';
     
558.         UART_send_buffer[length++] = '\r';
     
559.       }
     
560.     else
     
561.       break;
     
562.   }
     
563.   return length;
     
564. }
     
565. 
     
566. 
     
567. void Delay(uint32_t nTime)
     
568. {
     
569.   Gb_TimingDelay = nTime;
     
570. 
     
571.   while(Gb_TimingDelay != 0);
     
572. }
     
573. 
     
574. void SysTick_Handler(void)
     
575. {
     
576.   if (Gb_TimingDelay != 0x00)
     
577.   {
     
578.     Gb_TimingDelay--;
     
579.   }
     
580. }

复制代码

运行结果：

kk5290122

弄了这么多东西上去，奋斗哥幸苦了。不过貌似电子版很多人都有吧…………

奋斗哥

kk5290122 发表于 2013-7-26 11:36
弄了这么多东西上去，奋斗哥幸苦了。不过貌似电子版很多人都有吧………… ...

电子版？分享看看撒~

kk5290122

奋斗哥 发表于 2013-7-26 13:34
电子版？分享看看撒~

就这个呀…………

我的stm32f4学习历程.pdf (5.32 MB, 下载次数: 904)

2013-7-26 13:54 上传

点击文件名下载附件

奋斗哥

kk5290122 发表于 2013-7-26 13:55
就这个呀…………

哈哈，我上传过都忘记了{:soso_e143:} 展现出来大家也看看吧{:soso_e104:}

xiand_ni

不愧是奋斗哥。。。