《STM32F407 探索者开发指南》第五十八章 FPU测试(Julia分形)实验

正点原子运营

第五十八章 FPU测试(Julia分形)实验

1）实验平台：正点原子探索者STM32F407开发板

2) 章节摘自【正点原子】STM32F407开发指南 V1.1

3）购买链接:https://detail.tmall.com/item.htm?id=609294673401

4）全套实验源码+手册+视频下载地址：http://www.openedv.com/docs/boards/stm32/zdyz_stm32f407_explorerV3.html

5）正点原子官方B站：https://space.bilibili.com/394620890

6）STM32技术交流QQ群:151941872

本章我们将学习如何开启STM32F407的硬件FPU，并对比使用硬件FPU和不使用硬件FPU的速度差别，以体现硬件FPU的优势。

本章分为如下几个小节：

58.1 FPU&Julia分形简介

58.2 硬件设计

58.3 程序设计

58.4 下载验证

58.1 FPU&Julia分形简介

本节将分别介绍STM32F407的FPU和Julia分形。

58.1.1 FPU简介

FPU即浮点运算单元（Float Point Unit）。浮点运算，对于定点CPU（没有FPU的CPU）来说必须要按照IEEE-754标准的算法来完成运算，是相当耗费时间的。而对于有FPU的CPU来说，浮点运算则只是几条指令的事情，速度相当快。

STM32F407属于Cortex M4架构，带有32位单精度硬件FPU，支持浮点指令集，相对于Cortex M0和Cortex M3等，高出数十倍甚至上百倍的运算性能。

STM32F407硬件上要开启FPU是很简单的，通过一个叫：协处理器控制寄存器（CPACR）的寄存器设置即可开启STM32F407的硬件FPU，该寄存器各位描述如图58.1.1.1所示：                                 

图58.1.1.1 协处理器控制寄存器（CPACR）各位描述

这里我们就是要设置CP11和CP10这4个位，复位后，这4个位的值都为0，此时禁止访问协处理器（禁止了硬件FPU），我们将这4个位都设置为1，即可完全访问协处理器（开启硬件FPU），此时便可以使用STM32F407内置的硬件FPU了。CPACR寄存器这4个位的设置，我们在system_stm32f4xx.c文件里面开启，代码如下：

1. void SystemInit(void)
   
2. {
   
3. /* 省略部分代码 */
   
4.   /* FPU settings------------------------------------------------------------*/
   
5.   #if (__FPU_PRESENT == 1) && (__FPU_USED == 1)
   
6. SCB->CPACR |= ((3UL << (10*2))|(3UL << (11*2)));
   
7. /* set CP10 and CP11 Full Access */
   
8.   #endif
   
9. /* 省略部分代码 */
   
10. }

复制代码

此部分代码是系统初始化函数的部分内容，功能就是设置CPACR寄存器的20~23位为1，以开启STM32F407的硬件FPU功能。从程序可以看出，只要我们定义了全局宏定义标识符__FPU_PRESENT以及__FPU_USED为1，那么就可以开启硬件FPU。其中宏定义标识符__FPU_PRESENT用来确定处理器是否带FPU功能，标识符__FPU_USED用来确定是否开启FPU功能。

实际上，因为STM32F407是带FPU功能的，所以在我们的stm32f407xx.h头文件里面，我们默认是定义了__FPU_PRESENT为1。大家可以打开文件搜索即可找到下面一行代码：

1. #define __FPU_PRESENT             1U        /* FPU present */

复制代码

但是，仅仅只是说明处理器有FPU功能是不够的，我们还需要开启FPU功能。开启FPU有两种方法，第一种是直接在头文件stm32f407xx.h中定义宏定义标识符__FPU_USED的值为1。也可以直接在MDK编译器上面设置，我们在MDK5编译器里面，点击 按钮，然后在Target选项卡里面，设置Floating Point Hardware为Use SinglePrecision，如图58.1.1.2所示：     

图58.1.1.2 编译器开启硬件FPU选型

经过这个设置，编译器会自动加入标识符__FPU_USED为1。这样遇到浮点运算就会使用硬件FPU相关指令，执行浮点运算，从而大大减少计算时间。

最后，总结下STM32F407硬件FPU使用的要点：

1，  设置CPACR寄存器bit20~23为1，使能硬件FPU（参考SystemInit函数开头部分）。

2，  MDK编译器Target选项卡中Not Used选项设置为：Use Single Precision。

经过这两步设置，我们的编写的浮点运算代码，即可使用STM32F407的硬件FPU了，可以大大加快浮点运算速度。

58.1.2 Julia分形简介

Julia分形即Julia集，它最早由法国数学家Gaston Julia发现，因此命名为Julia（朱利亚）集。Julia集合的生成算法非常简单：对于复平面的每个点，我们计算一个定义序列的发散速度。该序列的 Julia 集计算公式为：

zn+1 = zn2 + c

针对复平面的每个 x + i.y 点，我们用 c = cx + i.cy 计算该序列：

xn+1 + i.yn+1 = xn2 - yn2+ 2.i.xn.yn + cx + i.cy

xn+1 = xn2 - yn2 +cx 且 yn+1= 2.xn.yn + cy

一旦计算出的复值超出给定圆的范围（数值大小大于圆半径），序列便会发散，达到此限值时完成的迭代次数与该点相关。随后将该值转换为颜色，以图形方式显示复平面上各个点的分散速度。

经过给定的迭代次数后，若产生的复值保持在圆范围内，则计算过程停止，并且序列也不发散，本例程生成Julia分形图片的代码如下：

1. #define     ITERATION            128           /* 迭代次数 */
   
2. #define     REAL_CONSTANT        0.285f       /* 实部常量 */
   
3. #define     IMG_CONSTANT         0.01f        /* 虚部常量 */
   
4. /**
   
5. *@brief        产生Julia分形图形
   
6. *@param        size_x      : 屏幕x方向的尺寸
   
7. *@param        size_y      : 屏幕y方向的尺寸
   
8. *@param        offset_x    : 屏幕x方向的偏移
   
9. * @param        offset_y    : 屏幕y方向的偏移
   
10. *@param        zoom         : 缩放因子
    
11. *@retval       无
    
12. */
    
13. voidjulia_generate_fpu(uint16_t size_x, uint16_t size_y, uint16_t offset_x,
    
14. uint16_t offset_y, uint16_t zoom)
    
15. {
    
16.     uint8_t i;
    
17.     uint16_t x, y;
    
18.     float tmp1, tmp2;
    
19.     float num_real, num_img;
    
20.     float radius;
    
21.     for (y = 0; y < size_y; y++)
    
22.     {
    
23.        for (x = 0; x < size_x; x++)
    
24.        {
    
25.            num_real = y - offset_y;
    
26.            num_real = num_real / zoom;
    
27.            num_img = x - offset_x;
    
28.            num_img = num_img / zoom;
    
29.            i = 0;
    
30.            radius = 0;
    
31.            while ((i < ITERATION - 1) && (radius < 4))
    
32.            {
    
33.                 tmp1 = num_real * num_real;
    
34.                 tmp2 = num_img * num_img;
    
35.                 num_img = 2 * num_real * num_img + IMG_CONSTANT;
    
36.                 num_real = tmp1 - tmp2 + REAL_CONSTANT;
    
37.                 radius = tmp1 + tmp2;
    
38.                 i++;
    
39.            }
    
40.            LCD->LCD_RAM = g_color_map; /* 绘制到屏幕 */
    
41.        }
    
42.     }
    
43. }

复制代码

这种算法非常有效地展示了 FPU 的优势：无需修改代码，只需在编译阶段激活或禁止 FPU（在MDKCode Generation的Float PointHardware选项里面设置：Single Precision /Not Used），即可测试使用硬件FPU和不使用硬件FPU的差距。

注意，是该函数将颜色数据填充到LCD的时候，根据MCU屏还是RGB屏，做了不同的处理：MCU屏可以直接写LCD_RAM，将颜色显示到LCD上面；而RGB屏，则需要先缓存到lcdbuf，然后通过DMA2D一次性填充，以提高速度。本实验不支持RGB屏，所以RGB屏的情况忽略即可。

58.2 硬件设计
1. 例程功能

1、实验开机后，根据迭代次数生成颜色表（RGB565），然后计算Julia分形，并显示到LCD上面。同时，程序开启了定时器6，用于统计一帧所要的时间（ms），在一帧Julia分形图片显示完成后，程序会显示运行时间、当前是否使用FPU和缩放因子（zoom）等信息，方便观察对比。KEY0/KEY1用于调节缩放因子，KEY_UP用于设置自动缩放，还是手动缩放。

2、LED0闪烁，提示程序运行。

2. 硬件资源

1）LED灯

    LED0 – PF9

2）串口1(PA9/PA10连接在板载USB转串口芯片CH340上面)

3）正点原子2.8/3.5/4.3/7寸TFTLCD模块(仅限MCU屏，16位8080并口驱动)

4）独立按键 ：

    KEY0 – PE4

    KEY1 – PE3

    KEY2 – PE2

    KEY_UP – PA0

5）FPU(浮点运算单元)

6）定时器6

58.3 程序设计
58.3.1 程序流程图

图58.3.1.1 FPU测试(Julia分形)实验程序流程图

58.3.2 程序解析

本实验例程，分成两个工程：

1，实验46_1 FPU测试(Julia分形)实验_开启硬件FPU

2，实验46_2 FPU测试(Julia分形)实验_关闭硬件FPU

这两个工程的代码一模一样，只是前者使用硬件FPU计算Julia分形集（MDK设置Single Precision），后者使用IEEE-754标准计算Julia分形集（MDK设置Not Used）。由于两个工程代码一模一样，我们这里仅介绍其中一个：实验46_1 FPU测试(Julia分形)实验_开启硬件FPU。

1. TIMER驱动代码

这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。由于要统计帧时间，所以我们需要用到TIMER驱动代码的btim.c和btim.h文件。

btim.h文件不需要做任何修改，只要在btim.c文件中，修改定时器更新中断回调函数即可，具体修改后的代码如下：

1. extern uint8_t g_timeout ;            /* 在main.c里面定义 */
   
2. /**
   
3. *@brief        定时器更新中断回调函数
   
4. *@param        htim:定时器句柄指针
   
5. *@retval       无
   
6. */
   
7. voidHAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
   
8. {
   
9.     if (htim == (&g_timx_handle))
   
10.     {
    
11.        g_timeout++;
    
12.        //LED1_TOGGLE();
    
13.     }
    
14. }

复制代码

在定时器更新中断回调函数中，我们只是需要让g_timeout自加就行，最后把g_timeout变量的值乘定时器更新中断的周期就可以得到帧时间了。当然在程序上，我们还要声明g_timeout变量。

2. main.c代码

下面是main.c的程序，具体如下：

1. /* FPU模式提示 */
   
2. #if __FPU_USED==1
   
3. #define SCORE_FPU_MODE                  "FPU On"
   
4. #else
   
5. #define SCORE_FPU_MODE                  "FPU Off"
   
6. #endif
   
7. #define     ITERATION            128          /* 迭代次数 */
   
8. #define     REAL_CONSTANT        0.285f       /* 实部常量 */
   
9. #define     IMG_CONSTANT         0.01f        /* 虚部常量 */
   
10. /* 颜色表 */
    
11. uint16_t g_color_map[ITERATION];
    
12. /* 缩放因子列表 */
    
13. const uint16_t zoom_ratio[] =
    
14. {
    
15.     120, 110, 100, 150, 200, 275, 350, 450,
    
16.     600, 800, 1000, 1200, 1500, 2000, 1500,
    
17.     1200, 1000, 800, 600, 450, 350, 275, 200,
    
18.     150, 100, 110,
    
19. };
    
20. /**
    
21. *@brief        初始化颜色表
    
22. *@param        clut     : 颜色表指针
    
23. *@retval       无
    
24. */
    
25. voidjulia_clut_init(uint16_t *clut)
    
26. {
    
27.     uint32_t i = 0x00;
    
28.     uint16_t  red = 0, green = 0, blue = 0;
    
29.     for (i = 0; i < ITERATION; i++) /* 产生颜色表 */
    
30.     {
    
31.        /* 产生RGB颜色值 */
    
32.        red = (i * 8 * 256 / ITERATION) % 256;
    
33.        green = (i * 6 * 256 / ITERATION) % 256;
    
34.        blue = (i * 4 * 256 / ITERATION) % 256;
    
35.       
    
36.        /* 将RGB888,转换为RGB565 */
    
37.        red = red >> 3;
    
38.        red = red << 11;
    
39.        green = green >> 2;
    
40.        green = green << 5;
    
41.        blue = blue >> 3;
    
42.        clut = red + green + blue;
    
43.     }
    
44. }
    
45. /* RGB LCD 缓存*/
    
46. uint16_t g_lcdbuf[800];
    
47. /**
    
48. *@brief        产生Julia分形图形
    
49. *@param        size_x      : 屏幕x方向的尺寸
    
50. *@param        size_y      : 屏幕y方向的尺寸
    
51. *@param        offset_x    : 屏幕x方向的偏移
    
52. *@param        offset_y    : 屏幕y方向的偏移
    
53. *@param        zoom         : 缩放因子
    
54. *@retval       无
    
55. */
    
56. void julia_generate_fpu(uint16_t size_x, uint16_t size_y, uint16_t offset_x, uint16_t offset_y, uint16_t zoom)
    
57. {
    
58.     uint8_t i;
    
59.     uint16_t x, y;
    
60.     float tmp1, tmp2;
    
61.     float num_real, num_img;
    
62.     float radius;
    
63.     for (y = 0; y < size_y; y++)
    
64.     {
    
65.        for (x = 0; x < size_x; x++)
    
66.        {
    
67.            num_real = y - offset_y;
    
68.            num_real = num_real / zoom;
    
69.            num_img = x - offset_x;
    
70.            num_img = num_img / zoom;
    
71.            i = 0;
    
72.            radius = 0;
    
73.            while ((i < ITERATION - 1) && (radius < 4))
    
74.            {
    
75.                 tmp1 = num_real * num_real;
    
76.                 tmp2 = num_img * num_img;
    
77.                 num_img = 2 * num_real * num_img + IMG_CONSTANT;
    
78.                 num_real = tmp1 - tmp2 + REAL_CONSTANT;
    
79.                 radius = tmp1 + tmp2;
    
80.                 i++;
    
81.            }
    
82.            LCD->LCD_RAM = g_color_map; /* 绘制到屏幕 */
    
83.        }
    
84.     }
    
85. }
    
86. uint8_t g_timeout;
    
87. int main(void)
    
88. {
    
89.     uint8_t key;
    
90.     uint8_t i = 0;
    
91.     uint8_t autorun = 0;
    
92.     float time;
    
93.     char buf[50];
    
94.    HAL_Init();                                 /* 初始化HAL库 */
    
95.    sys_stm32_clock_init(336, 8, 2, 7);     /* 设置时钟, 168Mhz */
    
96.    delay_init(168);                           /* 延时初始化 */
    
97.    usart_init(115200);                        /* 串口初始化为115200 */
    
98.    led_init();                                 /* 初始化LED */
    
99.    key_init();                                 /* 初始化按键 */
    
100.    lcd_init();                                 /* 初始化LCD */
     
101.    btim_timx_int_init(65535, 8400 - 1);    /* 10Khz计数频率,最大计时6.5秒超出 */
     
102.    lcd_show_string(30, 50, 200, 16, 16, "STM32", RED);
     
103.    lcd_show_string(30, 70, 200, 16, 16, "FPUTEST", RED);
     
104. lcd_show_string(30, 90, 200, 16, 16, "ATOM@ALIENTEK", RED);
     
105. lcd_show_string(30, 110, 200, 16, 16, "KEY0:+   KEY1:-", RED);
     
106. lcd_show_string(30, 130, 200, 16, 16, "KEY2:AUTO/MANUL", RED);/*显示提示信息*/
     
107.    delay_ms(1200);
     
108.    julia_clut_init(g_color_map);            /* 初始化颜色表 */
     
109.     while (1)
     
110.     {
     
111.        key = key_scan(0);
     
112.        switch (key)
     
113.        {
     
114.            case KEY0_PRES:
     
115.                 i++;
     
116.                 if (i > sizeof(zoom_ratio) / 2 - 1) i = 0;   /* 限制范围 */
     
117.                 break;
     
118.            case KEY1_PRES:
     
119.                 if (i) i--;
     
120.                 else i = sizeof(zoom_ratio) / 2 - 1;
     
121.                 break;
     
122.            case WKUP_PRES:
     
123.                 autorun = !autorun; /* 自动/手动 */
     
124.                 break;
     
125.        }
     
126.        if (autorun == 1)   /* 自动时,自动设置缩放因子 */
     
127.        {
     
128.            i++;
     
129.            if (i > sizeof(zoom_ratio) / 2 - 1)
     
130.            {
     
131.                 i = 0;      /* 限制范围 */
     
132.            }
     
133.        }
     
134.        lcd_set_window(0, 0, lcddev.width, lcddev.height);  /* 设置窗口 */
     
135.        lcd_write_ram_prepare();
     
136.        BTIM_TIMX_INT->CNT = 0;  /* 重设TIM6定时器的计数器值 */
     
137.        g_timeout = 0;
     
138.        julia_generate_fpu(lcddev.width, lcddev.height, lcddev.width / 2,
     
139. lcddev.height / 2, zoom_ratio);
     
140.        time =BTIM_TIMX_INT->CNT + (uint32_t)g_timeout * 65536;
     
141.        sprintf(buf, "%s: zoom:%d runtime:%0.1fms\r\n", SCORE_FPU_MODE,
     
142. zoom_ratio, time / 10);
     
143.        lcd_show_string(5, lcddev.height - 5 - 12, lcddev.width - 5,
     
144. 12, 12, buf, RED);  /* 显示当前运行情况 */
     
145.        printf("%s", buf);                   /* 输出到串口 */
     
146.        LED0_TOGGLE();
     
147.     }
     
148. }

复制代码

这部分程序，总共3个函数：julia_clut_init、julia_generate_fpu和main函数。

julia_clut_init函数，该函数用于初始化颜色表，该函数根据迭代次数（ITERATION）计算出颜色表，这些颜色值将显示在TFTLCD上。

GenerateJulia_fpu函数，该函数根据给定的条件计算Julia分形集，当迭代次数大于等于ITERATION或者半径大于等于4时，结束迭代，并在TFTLCD上面显示迭代次数对应的颜色值，从而得到漂亮的Julia分形图。我们可以通过修改REAL_CONSTANT和IMG_CONSTANT这两个常量的值来得到不同的Julia分形图。

main函数，完成我们在58.2节所介绍的实验功能，代码比较简单。这里我们用到一个缩放因子表：zoom_ratio，里面存储了一些不同的缩放因子，方便演示效果。

为了提高速度，我们还可以在MDK里面选择使用-O2优化，优化代码速度，本例程代码就介绍到这里。

再次提醒大家：本例程两个代码（实验46_1和实验46_2）程序是完全一模一样的，他们的区别就是MDKàOptions for Target ‘Target1’àTarget选项卡àFloating Point Hardware的设置不一样，当设置Single Precision时，使用硬件FPU；当设置Not Used时，不使用硬件FPU。分别下载这两个代码，通过屏幕显示的runtime时间，即可看出速度上的区别。

58.4 下载验证

将实验46_1的程序下载到开发板后，可以看到LCD首先显示一些实验相关的信息，然后开始显示Julia分形图，并显示相关参数，如图58.4.1所示：

图58.4.1Julia分形显示效果

实验46_1是开启了硬件FPU的，所以显示Julia分形图片速度比较快。除了LCD屏幕，还可以通过串口调试助手观察相关信息，如图58.4.2所示：     

图58.4.2Julia分形显示效果（开启硬件FPU）

下面是关闭硬件FPU的运行情况，如图58.4.3所示：     

图58.4.3Julia分形显示效果（关闭硬件FPU）

对比图58.4.2和图58.4.3知道，在同等情况下，关闭硬件FPU会比开启硬件FPU，运行速度慢8.6倍左右，这充分体现了STM32F407硬件FPU的优势。