使用DMA，让LCD_Fill函数速度提升62%

854278507

正点原子提供的LCD_Fill函数是使用CPU运算的方式，整屏填充需要10.375ms，算下来就是48.131帧，虽然已经很快了，但是如果使用DMA，还可以更快
下面是我修改后的LCD_Fill函数

1. // 在指定区域内填充单个颜色
   
2. //(sx,sy),(ex,ey):填充矩形对角坐标,区域大小为:(ex-sx+1)*(ey-sy+1)
   
3. // color:要填充的颜色
   
4. void LCD_Fill(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint16_t color)
   
5. {
   
6. 
   
7.     uint16_t i, j;
   
8.     uint16_t xlen = 0;
   
9.     uint16_t temp;
   
10. 
    
11. 
    
12.     if ((lcddev.id == 0x6804) && (lcddev.dir == 1)) // 6804横屏的时候特殊处理
    
13.     {
    
14.         temp = sx;
    
15.         sx = sy;
    
16.         sy = lcddev.width - ex - 1;
    
17.         ex = ey;
    
18.         ey = lcddev.width - temp - 1;
    
19.         lcddev.dir = 0;
    
20.         lcddev.setxcmd = 0x2A;
    
21.         lcddev.setycmd = 0x2B;
    
22.         LCD_Fill(sx, sy, ex, ey, color);
    
23.         lcddev.dir = 1;
    
24.         lcddev.setxcmd = 0x2B;
    
25.         lcddev.setycmd = 0x2A;
    
26.     }
    
27.     else
    
28.     {
    
29. #if 1
    
30.         uint16_t width;
    
31.         uint16_t height;
    
32.         
    
33.         width = ex - sx + 1;
    
34.         height = ey - sy + 1;
    
35.         
    
36.         
    
37.         
    
38.         LCD_Set_Window(sx, sy, width, height);
    
39.         LCD_WriteRAM_Prepare();
    
40.         
    
41.         uint32_t lcdsize = width * height;
    
42.         uint32_t dmatransfered = 0;
    
43.         
    
44.         uint16_t color_buf[2];
    
45.         
    
46.         color_buf[0] = color;
    
47.         color_buf[1] = color;
    
48.         
    
49. 
    
50.         DMA_InitTypeDef DMA_InitStruct;
    
51.         
    
52.         lcdsize /= 2; /* 使用32位宽数据传输，数据量减少一半 */
    
53.         
    
54.         DMA_InitStruct.DMA_PeripheralBaseAddr  = (uint32_t)&LCD->LCD_RAM;   /* 外设地址为LCD_RAM */   
    
55.         DMA_InitStruct.DMA_MemoryBaseAddr = (uint32_t)color_buf;            /* 内存地址为显示缓存 */
    
56.         DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralDST;                     /* DMA方向为内存到外设 */   
    
57.         DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;       /* 外设地址固定 */
    
58.         DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Disable;               /* 内存地址固定 */
    
59.         DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Word;/* 外设数据宽度32位 */
    
60.         DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Word;        /* 内存数据宽度32位 */
    
61.         DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;                          /* 普通模式 */
    
62.         DMA_InitStruct.DMA_Priority = DMA_Priority_High;                    /* DMA优先级为高 */
    
63.         DMA_InitStruct.DMA_M2M = DMA_M2M_Enable;                            /* 内存到内存模式（不需要外部触发） */   
    
64.         
    
65.         while (lcdsize)
    
66.         {
    
67.             if (lcdsize >= 65535)
    
68.             {
    
69.                 DMA_InitStruct.DMA_BufferSize = 65535; /* 单次数据传输量不能超过65535 */
    
70.                 lcdsize -= 65535;
    
71.                 dmatransfered += 65535;
    
72.             }
    
73.             else
    
74.             {
    
75.                 DMA_InitStruct.DMA_BufferSize = lcdsize;
    
76.                 lcdsize = 0;
    
77.             }
    
78.             
    
79.             DMA_Init(DMA2_Channel5, &DMA_InitStruct);
    
80.             
    
81.             DMA_Cmd(DMA2_Channel5, ENABLE);
    
82.             
    
83.             while (DMA_GetFlagStatus(DMA2_FLAG_TC5) == RESET)
    
84.             {
    
85.                
    
86.             }            
    
87.             
    
88.             DMA_ClearFlag(DMA2_FLAG_TC5);
    
89. 
    
90.         }
    
91.         DMA_Cmd(DMA2_Channel5, DISABLE);
    
92.         
    
93.         LCD_Set_Window(0, 0, lcddev.width, lcddev.height);
    
94. //        LCD_WriteRAM_Prepare();
    
95.         
    
96. #else
    
97.         
    
98.         xlen = ex - sx + 1;
    
99.         for (i = sy; i <= ey; i++)
    
100.         {
     
101.             LCD_SetCursor(sx, i);      // 设置光标位置
     
102.             LCD_WriteRAM_Prepare();    // 开始写入GRAM
     
103.             for (j = 0; j < xlen; j++) // 显示颜色
     
104.             {
     
105.                 LCD->LCD_RAM = color;
     
106.             }
     
107.         }
     
108.         
     
109. #endif /* 0 */
     
110.     }
     
111. }

复制代码

可能会有人有疑问，LCD是16位的8080 16位的接口，怎么可以使用32位的数据传输，实际上是可以的，也可以改成16位传输，这样速度会慢一点，因为 240 * 320 的屏用16位传输需要写 240 * 320 = 76800次，而STM32F103的DMA一次最多只能传输65535个数据，需要分两次传输，如果用32位传输就只需要 240 * 320 / 2 = 38400次，DMA一次就可以传输完成。
由于是单色填充，需要先定义一个数组，填充好要用的颜色数值，然后把这地址设置为DMA的内存地址，初始化DMA的时候要设置内存地址不自增，这样就可以快速整屏填充了。

下面是没有使用DMA刷屏速度截图

从上面的图片可以看出没有使用DMA的时候刷一屏需要10.375ms，刷屏速度48.131帧。

下面是使用DMA刷屏速度截图

从上面的图片可以看出使用DMA后刷一屏只需要6.411ms，刷屏速度77.99帧。

下面放上测试刷屏速度的代码

1. 
   
2. void lcd_test_play(void)
   
3. {
   
4. #if 1
   
5. 
   
6.     const uint16_t color_table[] =
   
7.     {
   
8.         //画笔颜色
   
9.         WHITE             ,
   
10.         BLACK             ,
    
11.         BLUE              ,
    
12.         BRED              ,
    
13.         GRED                           ,
    
14.         GBLUE                          ,
    
15.         RED               ,
    
16.         MAGENTA           ,
    
17.         GREEN             ,
    
18.         CYAN              ,
    
19.         YELLOW            ,
    
20.         BROWN                           ,
    
21.         BRRED                           ,
    
22.         GRAY                            ,
    
23.         DARKBLUE          ,
    
24.         LIGHTBLUE         ,
    
25.         GRAYBLUE          ,
    
26.         LIGHTGREEN        ,
    
27.         LGRAY                           ,
    
28.         LGRAYBLUE         ,
    
29.         LBBLUE            ,
    
30.     };
    
31.       
    
32.     uint8_t i;
    
33. 
    
34.    
    
35. 
    
36.     spb_delete();
    
37.         printf("\r\n[%s][%s][%04d]LCD刷屏 %d",
    
38.                __FILE__, __func__, __LINE__, system_task_return);
    
39.     system_task_return = 0;
    
40.    
    
41.     while (1)
    
42.     {
    
43.         for (i = 0; i < sizeof(color_table) / 2; i++)
    
44.         {
    
45.             LCD_Fill(0, 0, lcddev.width - 1, lcddev.height - 1, color_table[i]);   
    
46.             LED_1_Turn();
    
47.         }
    
48.         
    
49.         if (system_task_return == 1)
    
50.         {
    
51.             if (TPAD_Scan(1))
    
52.             {
    
53.                 break;
    
54.             }
    
55.             else
    
56.             {
    
57.                 system_task_return = 0;
    
58.             }
    
59.         }
    
60.     }
    
61.     LED_1_Off();  
    
62.    
    
63. #else
    
64. 
    
65. 
    
66.     uint16_t r;
    
67.     uint16_t g;
    
68.     uint16_t b;
    
69.    
    
70. 
    
71.     spb_delete();
    
72.         printf("\r\n[%s][%s][%04d]LCD刷屏 %d",
    
73.                __FILE__, __func__, __LINE__, system_task_return);
    
74.     system_task_return = 0;
    
75.    
    
76.     while (1)
    
77.     {
    
78. #define LCD_DELAY 20
    
79. 
    
80.         for (r = 0; r < (1 << 5); r++)
    
81.         {
    
82.             for (g = 0; g < (1 << 6); g++)
    
83.             {
    
84.                 for (b = 0; b < (1 << 5); b++)
    
85.                 {
    
86.                     LCD_Fill(0,
    
87.                     0,
    
88.                     lcddev.width - 1,
    
89.                     lcddev.height - 1,
    
90.                     (r << 11) | (g << 5) | b);
    
91.                     LED_1_Turn();
    
92.                     OSTimeDly(LCD_DELAY);
    
93.                 }
    
94.                 for (b = (1 << 5); b > 0; b--)
    
95.                 {
    
96.                     LCD_Fill(0,
    
97.                     0,
    
98.                     lcddev.width - 1,
    
99.                     lcddev.height - 1,
    
100.                     (r << 11) | (g << 5) | b);
     
101.                     LED_1_Turn();
     
102.                     OSTimeDly(LCD_DELAY);
     
103.                 }               
     
104.             }
     
105.             for (g = (1 << 6); g > 0; g--)
     
106.             {
     
107.                 for (b = 0; b < (1 << 5); b++)
     
108.                 {
     
109.                     LCD_Fill(0,
     
110.                     0,
     
111.                     lcddev.width - 1,
     
112.                     lcddev.height - 1,
     
113.                     (r << 11) | (g << 5) | b);
     
114.                     LED_1_Turn();
     
115.                     OSTimeDly(LCD_DELAY);
     
116.                 }
     
117.                 for (b = (1 << 5); b > 0; b--)
     
118.                 {
     
119.                     LCD_Fill(0,
     
120.                     0,
     
121.                     lcddev.width - 1,
     
122.                     lcddev.height - 1,
     
123.                     (r << 11) | (g << 5) | b);
     
124.                     LED_1_Turn();
     
125.                     OSTimeDly(LCD_DELAY);
     
126.                 }               
     
127.             }            
     
128.         }
     
129.         
     
130.         for (r = (1 << 5); r > 0; r--)
     
131.         {
     
132.             for (g = 0; g < (1 << 6); g++)
     
133.             {
     
134.                 for (b = 0; b < (1 << 5); b++)
     
135.                 {
     
136.                     LCD_Fill(0,
     
137.                     0,
     
138.                     lcddev.width - 1,
     
139.                     lcddev.height - 1,
     
140.                     (r << 11) | (g << 5) | b);
     
141.                     LED_1_Turn();
     
142.                     OSTimeDly(LCD_DELAY);
     
143.                 }
     
144.                 for (b = (1 << 5); b > 0; b--)
     
145.                 {
     
146.                     LCD_Fill(0,
     
147.                     0,
     
148.                     lcddev.width - 1,
     
149.                     lcddev.height - 1,
     
150.                     (r << 11) | (g << 5) | b);
     
151.                     LED_1_Turn();
     
152.                     OSTimeDly(LCD_DELAY);
     
153.                 }               
     
154.             }
     
155.             for (g = (1 << 6); g > 0; g--)
     
156.             {
     
157.                 for (b = 0; b < (1 << 5); b++)
     
158.                 {
     
159.                     LCD_Fill(0,
     
160.                     0,
     
161.                     lcddev.width - 1,
     
162.                     lcddev.height - 1,
     
163.                     (r << 11) | (g << 5) | b);
     
164.                     LED_1_Turn();
     
165.                     OSTimeDly(LCD_DELAY);
     
166.                 }
     
167.                 for (b = (1 << 5); b > 0; b--)
     
168.                 {
     
169.                     LCD_Fill(0,
     
170.                     0,
     
171.                     lcddev.width - 1,
     
172.                     lcddev.height - 1,
     
173.                     (r << 11) | (g << 5) | b);
     
174.                     LED_1_Turn();
     
175.                     OSTimeDly(LCD_DELAY);
     
176.                 }               
     
177.             }            
     
178.         }        
     
179.         
     
180.         if (system_task_return == 1)
     
181.         {
     
182.             if (TPAD_Scan(1))
     
183.             {
     
184.                 break;
     
185.             }
     
186.             else
     
187.             {
     
188.                 system_task_return = 0;
     
189.             }
     
190.         }
     
191.     }
     
192.     LED_1_Off();   
     
193.    
     
194. #endif /* 1 */
     
195.    
     
196.    
     
197. }
     

复制代码

maidilong

16根数据线可以用DMA32位转输？？可以上传个完整代码试一下吗？好奇想试试