• 基于stm32F103的座面声控台灯

    1.基本内容：

            设计一个放置在桌面使用的台灯，使用220v交流电供电。具备显示屏能够实时显示日期（年、月、日和星期），时间（小时、分钟、秒）和温度（摄氏度）；能够通过语音交互播报实时日期、时间或者温度；能够通过语音交互控制桌面台灯的开启与关闭（或者明暗程度）。设计符合安全规范，符合日常家居使用习惯，操作简便，符合人性化需求。

    2.演示视频

    桌面指针式时钟与语音台灯设计

    3.设计准备

            LD3320语音识别模块、SYN6288语音合成模块、DHT11温湿度传感器模块+SL-Link下载器、STM32F103VET6、杜邦线、ILI9341液晶屏(野火stm32f103可一起购买）。

    4.代码讲解

    syn6288.c

    1. #include "syn6288.h"
    2. #include "stdarg.h"
    3.  
    4. xSYN6288_TypeDef  xSYN6288;                // 全局变量结构体
    5.  
    6. static void delay_ms(uint32_t ms)          // 简单的延时函数
    7. {
    8. 	 uint32_t i = 0;
    9.     ms = ms * 11993;                       
    10.     for (; i < ms; i++);    
    11. }
    12.  
    13.  
    14. //Music:选择背景音乐。0:无背景音乐，1~15：选择背景音乐
    15. // SYN6288_SendFrameInfo(0, "[v10][m1][t5]结算金额 为32.8元");
    16. // 参数： 0~15  :  背景音乐，0_无背景音乐，1~15_背景音乐可选
    17. //       [V0~16]:  文本朗读音量，0_最小，16_最大
    18. //       [m0~16]:  背景音乐音量，0_最小，16_最大
    19. //       [t0~5]:   朗读语速，0_最慢，5_最快
    20. //       其它不常用功能请参考数据手册
    21. static void SYN6288_SendFrameInfo(uint8_t Music, uint8_t *HZdata)
    22. {
    23.     /****************需要发送的文本**********************************/
    24.     unsigned  char  Frame_Info[50];
    25.     unsigned  char  HZ_Length;
    26.     unsigned  char  ecc  = 0;             //定义校验字节
    27.     unsigned  int i = 0;
    28.     HZ_Length = strlen((char *)HZdata);   //需要发送文本的长度
    29.  
    30.     /*****************帧固定配置信息**************************************/
    31.     Frame_Info[0] = 0xFD ;                //构造帧头FD
    32.     Frame_Info[1] = 0x00 ;                //构造数据区长度的高字节
    33.     Frame_Info[2] = HZ_Length + 3;        //构造数据区长度的低字节
    34.     Frame_Info[3] = 0x01 ;                //构造命令字：合成播放命令
    35.     Frame_Info[4] = 0x01 | Music << 4 ;   //构造命令参数：背景音乐设定
    36.  
    37.     /*******************校验码计算***************************************/
    38.     for (i = 0; i < 5; i++)               //依次发送构造好的5个帧头字节
    39.         ecc = ecc ^ (Frame_Info[i]);      //对发送的字节进行异或校验
    40.  
    41.     for (i = 0; i < HZ_Length; i++)       //依次发送待合成的文本数据
    42.         ecc = ecc ^ (HZdata[i]);          //对发送的字节进行异或校验
    43.     /*******************发送帧信息***************************************/
    44.     memcpy(&Frame_Info[5], HZdata, HZ_Length);
    45.     Frame_Info[5 + HZ_Length] = ecc;
    46.     if (xSYN6288.USARTx == USART1)   USART1_SendData(Frame_Info, 5 + HZ_Length + 1);
    47.     if (xSYN6288.USARTx == USART2)   USART2_SendData(Frame_Info, 5 + HZ_Length + 1);
    48.     if (xSYN6288.USARTx == USART3)   USART3_SendData(Frame_Info, 5 + HZ_Length + 1);
    49.     if (xSYN6288.USARTx == UART4)    UART4_SendData(Frame_Info, 5 + HZ_Length + 1);
    50.     if (xSYN6288.USARTx == UART5)    UART5_SendData(Frame_Info, 5 + HZ_Length + 1);
    51. }
    52.  
    53.  
    54.  
    55. /***********************************************************
    56. * 名    称： SYN6288_Set(uint8_t *Info_data)
    57. * 功    能： 主函数 程序入口
    58. * 入口参数： *Info_data:固定的配置信息变量
    59. * 出口参数：
    60. * 说    明：本函数用于配置，停止合成、暂停合成等设置 ，默认波特率9600bps。
    61. * 调用方法：通过调用已经定义的相关数组进行配置。
    62. **********************************************************/
    63. static void SYN6288_Set(uint8_t *Info_data)
    64. {
    65.     uint8_t Com_Len;
    66.     Com_Len = strlen((char *)Info_data);
    67.     UART5_SendData(Info_data, Com_Len);
    68. }
    69.  
    70.  
    71. /******************************************************************************
    72.  * 函  数： SYN6288_Say
    73.  * 功  能： 输出合成语音
    74.  * 参  数： 格式化参数，如printf参数般一样的用法
    75.  * 返回值： 无
    76.  * 示  例： SYN6288_Say("你好吗?");
    77. *******************************************************************************/
    78. void SYN6288_Say(char *fmt, ...)
    79. {
    80.     static char  str_1[200];   // 缓存区1，模块每次可转换200字节
    81.     static char  str_2[200];   // 缓存区2，模块每次可转换200字节
    82.     va_list ap;
    83.     va_start(ap, fmt);
    84.     vsprintf(str_1, fmt, ap);
    85.     va_end(ap);
    86.     sprintf(str_2, "[d][V12][m15][t5]%s", str_1);  // [d]恢复默认状态，[V12]朗读音量0~16，[m15]背景音量0~16，[t5]语速0~5
    87.     SYN6288_SendFrameInfo(0, (uint8_t *)str_2); // 无背景音乐
    88. }
    89.  
    90. /******************************************************************************
    91.  * 函  数： SYN6288_Init
    92.  * 功  能： 初始化所用串口, 模块默认通信波特率9600
    93.  * 参  数： 串口-USARTx
    94.  * 返回值： 无
    95.  * 示  例： SYN6288_Init(USART1);
    96. *******************************************************************************/
    97. void SYN6288_Init(USART_TypeDef *USARTx)
    98. {
    99.     uint16_t baudrate = 9600;      // 默认波特率9600bps。
    100.     delay_ms(200);                 // 上电后，稍作延时，等待模块进入稳定状态
    101.     if (USARTx == USART1)    USART1_Init(baudrate);
    102.     if (USARTx == USART2)    USART2_Init(baudrate);
    103.     if (USARTx == USART3)    USART3_Init(baudrate);
    104. #ifdef STM32F10X_HD
    105.     if (USARTx == UART4)     UART4_Init(baudrate);
    106.     if (USARTx == UART5)     UART5_Init(baudrate);
    107. #endif
    108.     xSYN6288.FlagOkay = 0;         // 初始化状态
    109.     xSYN6288.USARTx   = USARTx;    // 记录所用串口端口
    110. }

    DHT11.c

    1. #include "DTH11.h"
    2. #include "bsp_systick.h"
    3. #include "stdio.h"
    4. static void                           DHT11_GPIO_Config                       ( void );
    5. static void                           DHT11_Mode_IPU                          ( void );
    6. static void                           DHT11_Mode_Out_PP                       ( void );
    7. static uint8_t                        DHT11_ReadByte                          ( void );
    8.  
    9.  
    10. /**
    11.   * @brief  DHT11 初始化函数
    12.   * @param  无
    13.   * @retval 无
    14.   */
    15. void DHT11_Init ( void )
    16. {
    17.         DHT11_GPIO_Config ();
    18.        
    19.         DHT11_Dout_1;               // 拉高GPIOB10
    20. }
    21.  
    22. /*
    23. * 函数名：DHT11_GPIO_Config
    24. * 描述  ：配置DHT11用到的I/O口
    25. * 输入  ：无
    26. * 输出  ：无
    27. */
    28. static void DHT11_GPIO_Config ( void )
    29. {               
    30.         /*定义一个GPIO_InitTypeDef类型的结构体*/
    31.         GPIO_InitTypeDef GPIO_InitStructure;
    32.  
    33.        
    34.         /*开启DHT11_Dout_GPIO_PORT的外设时钟*/
    35. 			DHT11_Dout_SCK_APBxClock_FUN ( DHT11_Dout_GPIO_CLK, ENABLE );       
    36.  
    37.         /*选择要控制的DHT11_Dout_GPIO_PORT引脚*/                                                                                                                          
    38.           GPIO_InitStructure.GPIO_Pin = DHT11_Dout_GPIO_PIN;       
    39.  
    40.         /*设置引脚模式为通用推挽输出*/
    41.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
    42.  
    43.         /*设置引脚速率为50MHz */   
    44.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    45.  
    46.         /*调用库函数，初始化DHT11_Dout_GPIO_PORT*/
    47.           GPIO_Init ( DHT11_Dout_GPIO_PORT, &GPIO_InitStructure );                  
    48.        
    49. }
    50.  
    51. /*
    52. * 函数名：DHT11_Mode_IPU
    53. * 描述  ：使DHT11-DATA引脚变为上拉输入模式
    54. * 输入  ：无
    55. * 输出  ：无
    56. */
    57. static void DHT11_Mode_IPU(void)
    58. {
    59.           GPIO_InitTypeDef GPIO_InitStructure;
    60.  
    61.                   /*选择要控制的DHT11_Dout_GPIO_PORT引脚*/       
    62.           GPIO_InitStructure.GPIO_Pin = DHT11_Dout_GPIO_PIN;
    63.  
    64.            /*设置引脚模式为浮空输入模式*/
    65.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU ;
    66.  
    67.           /*调用库函数，初始化DHT11_Dout_GPIO_PORT*/
    68.           GPIO_Init(DHT11_Dout_GPIO_PORT, &GPIO_InitStructure);         
    69.        
    70. }
    71.  
    72. /*
    73. * 函数名：DHT11_Mode_Out_PP
    74. * 描述  ：使DHT11-DATA引脚变为推挽输出模式
    75. * 输入  ：无
    76. * 输出  ：无
    77. */
    78. static void DHT11_Mode_Out_PP(void)
    79. {
    80.         GPIO_InitTypeDef GPIO_InitStructure;
    81.  
    82.                  /*选择要控制的DHT11_Dout_GPIO_PORT引脚*/                                                                                                                          
    83.           GPIO_InitStructure.GPIO_Pin = DHT11_Dout_GPIO_PIN;       
    84.  
    85.         /*设置引脚模式为通用推挽输出*/
    86.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   
    87.  
    88.         /*设置引脚速率为50MHz */   
    89.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    90.  
    91.         /*调用库函数，初始化DHT11_Dout_GPIO_PORT*/
    92.           GPIO_Init(DHT11_Dout_GPIO_PORT, &GPIO_InitStructure);                  
    93.        
    94. }
    95.  
    96. /*
    97. * 从DHT11读取一个字节，MSB先行
    98. */
    99. static uint8_t DHT11_ReadByte ( void )
    100. {
    101.         uint8_t i, temp=0;
    102.        
    103.  
    104.         for(i=0;i<8;i++)   
    105.         {         
    106.                 /*每bit以50us低电平标置开始，轮询直到从机发出 的50us 低电平 结束*/  
    107.                 while(DHT11_Dout_IN()==Bit_RESET);
    108.  
    109.                 /*DHT11 以26~28us的高电平表示“0”，以70us高电平表示“1”，
    110.                  *通过检测 x us后的电平即可区别这两个状 ，x 即下面的延时
    111.                  */
    112.                 Systick_Delay_us(40); //延时x us 这个延时需要大于数据0持续的时间即可                     
    113.  
    114.                 if(DHT11_Dout_IN()==Bit_SET)/* x us后仍为高电平表示数据“1” */
    115.                 {
    116.                         /* 等待数据1的高电平结束 */
    117.                         while(DHT11_Dout_IN()==Bit_SET);
    118.  
    119.                         temp|=(uint8_t)(0x01<<(7-i));  //把第7-i位置1，MSB先行
    120.                 }
    121.                 else         // x us后为低电平表示数据“0”
    122.                 {                          
    123.                         temp&=(uint8_t)~(0x01<<(7-i)); //把第7-i位置0，MSB先行
    124.                 }
    125.         }
    126.        
    127.         return temp;
    128.        
    129. }
    130.  
    131.  
    132. /*
    133. * 一次完整的数据传输为40bit，高位先出
    134. * 8bit 湿度整数 + 8bit 湿度小数 + 8bit 温度整数 + 8bit 温度小数 + 8bit 校验和
    135. */
    136. uint8_t DHT11_Read_TempAndHumidity(DHT11_Data_TypeDef *DHT11_Data)
    137. {  
    138.         /*输出模式*/
    139.         DHT11_Mode_Out_PP();
    140.         /*主机拉低*/
    141.         DHT11_Dout_0;
    142.         /*延时18ms*/
    143.         Systick_Delay_ms(18);
    144.  
    145.         /*总线拉高 主机延时30us*/
    146.         DHT11_Dout_1;
    147.  
    148.         Systick_Delay_us(30);   //延时30us
    149.  
    150.         /*主机设为输入 判断从机响应信号*/
    151.         DHT11_Mode_IPU();
    152.  
    153.         /*判断从机是否有低电平响应信号 如不响应则跳出，响应则向下运行*/   
    154.         if(DHT11_Dout_IN()==Bit_RESET)     
    155.         {
    156.                 /*轮询直到从机发出 的80us 低电平 响应信号结束*/  
    157.                 while(DHT11_Dout_IN()==Bit_RESET);
    158.  
    159.                 /*轮询直到从机发出的 80us 高电平 标置信号结束*/
    160.                 while(DHT11_Dout_IN()==Bit_SET);
    161.  
    162.                 /*开始接收数据*/   
    163.                 DHT11_Data->humi_int= DHT11_ReadByte();
    164.  
    165.                 DHT11_Data->humi_deci= DHT11_ReadByte();
    166.  
    167.                 DHT11_Data->temp_int= DHT11_ReadByte();
    168.  
    169.                 DHT11_Data->temp_deci= DHT11_ReadByte();
    170.  
    171.                 DHT11_Data->check_sum= DHT11_ReadByte();
    172.  
    173.  
    174.                 /*读取结束，引脚改为输出模式*/
    175.                 DHT11_Mode_Out_PP();
    176.                 /*主机拉高*/
    177.                 DHT11_Dout_1;
    178.  
    179.                 /*检查读取的数据是否正确*/
    180.                 if(DHT11_Data->check_sum == DHT11_Data->humi_int + DHT11_Data->humi_deci + DHT11_Data->temp_int+ DHT11_Data->temp_deci)
    181.                         return SUCCESS;
    182.                 else
    183.                         return ERROR;
    184.         }
    185.        
    186.         else
    187.                 return ERROR;
    188.        
    189. }
    190.  
    191.

    ili9341.c

    1. /**
    2.   ******************************************************************************
    3.   * @file    bsp_ili9341_lcd.c
    4.   * @version V1.0
    5.   * @date    2013-xx-xx
    6.   * @brief   ili9341液晶屏驱动
    7.   ******************************************************************************
    8.   * @attention
    9.   *
    10.   * 实验平台:秉火 F103-指南者 STM32 开发板 
    11.   * 论坛    :http://www.firebbs.cn
    12.   * 淘宝    :http://firestm32.taobao.com
    13.   *
    14.   ******************************************************************************
    15.   */ 
    16.  
    17. #include "./lcd/bsp_ili9341_lcd.h"
    18. #include "./font/fonts.h"	
    19. #include 
    20.  
    21. //根据液晶扫描方向而变化的XY像素宽度
    22. //调用ILI9341_GramScan函数设置方向时会自动更改
    23. uint16_t LCD_X_LENGTH = ILI9341_LESS_PIXEL;
    24. uint16_t LCD_Y_LENGTH = ILI9341_MORE_PIXEL;
    25.  
    26. //液晶屏扫描模式，本变量主要用于方便选择触摸屏的计算参数
    27. //参数可选值为0-7
    28. //调用ILI9341_GramScan函数设置方向时会自动更改
    29. //LCD刚初始化完成时会使用本默认值
    30. uint8_t LCD_SCAN_MODE = 6;
    31.  
    32.  
    33.  
    34.  
    35. /**
    36.   * @brief  向ILI9341写入命令
    37.   * @param  usCmd :要写入的命令（表寄存器地址）
    38.   * @retval 无
    39.   */	
    40. __inline void ILI9341_Write_Cmd ( uint16_t usCmd )
    41. {
    42. 	* ( __IO uint16_t * ) ( FSMC_Addr_ILI9341_CMD ) = usCmd;
    43. 	
    44. }
    45.  
    46.  
    47. /**
    48.   * @brief  向ILI9341写入数据
    49.   * @param  usData :要写入的数据
    50.   * @retval 无
    51.   */	
    52. __inline void ILI9341_Write_Data ( uint16_t usData )
    53. {
    54. 	* ( __IO uint16_t * ) ( FSMC_Addr_ILI9341_DATA ) = usData;
    55. 	
    56. }
    57.  
    58.  
    59. /**
    60.   * @brief  从ILI9341读取数据
    61.   * @param  无
    62.   * @retval 读取到的数据
    63.   */	
    64. __inline uint16_t ILI9341_Read_Data ( void )
    65. {
    66. 	return ( * ( __IO uint16_t * ) ( FSMC_Addr_ILI9341_DATA ) );
    67. 	
    68. }
    69.  
    70.  
    71. /**
    72.   * @brief  用于 ILI9341 简单延时函数
    73.   * @param  nCount ：延时计数值
    74.   * @retval 无
    75.   */	
    76. static void ILI9341_Delay ( __IO uint32_t nCount )
    77. {
    78.   for ( ; nCount != 0; nCount -- );
    79. 	
    80. }
    81.  
    82.  
    83. /**
    84.   * @brief  初始化ILI9341的IO引脚
    85.   * @param  无
    86.   * @retval 无
    87.   */
    88. static void ILI9341_GPIO_Config ( void )
    89. {
    90. 	GPIO_InitTypeDef GPIO_InitStructure;
    91.  
    92. 	/* 使能FSMC对应相应管脚时钟*/
    93. 	RCC_APB2PeriphClockCmd ( 	
    94. 													/*控制信号*/
    95. 													ILI9341_CS_CLK|ILI9341_DC_CLK|ILI9341_WR_CLK|
    96. 													ILI9341_RD_CLK	|ILI9341_BK_CLK|ILI9341_RST_CLK|
    97. 													/*数据信号*/
    98. 													ILI9341_D0_CLK|ILI9341_D1_CLK|	ILI9341_D2_CLK | 
    99. 													ILI9341_D3_CLK | ILI9341_D4_CLK|ILI9341_D5_CLK|
    100. 													ILI9341_D6_CLK | ILI9341_D7_CLK|ILI9341_D8_CLK|
    101. 													ILI9341_D9_CLK | ILI9341_D10_CLK|ILI9341_D11_CLK|
    102. 													ILI9341_D12_CLK | ILI9341_D13_CLK|ILI9341_D14_CLK|
    103. 													ILI9341_D15_CLK	, ENABLE );
    104. 		
    105. 	
    106. 	/* 配置FSMC相对应的数据线,FSMC-D0~D15 */	
    107. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    108. 	GPIO_InitStructure.GPIO_Mode =  GPIO_Mode_AF_PP;
    109. 	
    110. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D0_PIN;
    111. 	GPIO_Init ( ILI9341_D0_PORT, & GPIO_InitStructure );
    112.  
    113. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D1_PIN;
    114. 	GPIO_Init ( ILI9341_D1_PORT, & GPIO_InitStructure );
    115. 	
    116. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D2_PIN;
    117. 	GPIO_Init ( ILI9341_D2_PORT, & GPIO_InitStructure );
    118. 	
    119. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D3_PIN;
    120. 	GPIO_Init ( ILI9341_D3_PORT, & GPIO_InitStructure );
    121. 	
    122. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D4_PIN;
    123. 	GPIO_Init ( ILI9341_D4_PORT, & GPIO_InitStructure );
    124. 	
    125. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D5_PIN;
    126. 	GPIO_Init ( ILI9341_D5_PORT, & GPIO_InitStructure );
    127. 	
    128. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D6_PIN;
    129. 	GPIO_Init ( ILI9341_D6_PORT, & GPIO_InitStructure );
    130. 	
    131. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D7_PIN;
    132. 	GPIO_Init ( ILI9341_D7_PORT, & GPIO_InitStructure );
    133. 	
    134. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D8_PIN;
    135. 	GPIO_Init ( ILI9341_D8_PORT, & GPIO_InitStructure );
    136. 	
    137. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D9_PIN;
    138. 	GPIO_Init ( ILI9341_D9_PORT, & GPIO_InitStructure );
    139. 	
    140. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D10_PIN;
    141. 	GPIO_Init ( ILI9341_D10_PORT, & GPIO_InitStructure );
    142. 	
    143. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D11_PIN;
    144. 	GPIO_Init ( ILI9341_D11_PORT, & GPIO_InitStructure );
    145.  
    146. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D12_PIN;
    147. 	GPIO_Init ( ILI9341_D12_PORT, & GPIO_InitStructure );	
    148. 	
    149. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D13_PIN;
    150. 	GPIO_Init ( ILI9341_D13_PORT, & GPIO_InitStructure );
    151. 	
    152. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D14_PIN;
    153. 	GPIO_Init ( ILI9341_D14_PORT, & GPIO_InitStructure );
    154. 	
    155. 	GPIO_InitStructure.GPIO_Pin = ILI9341_D15_PIN;
    156. 	GPIO_Init ( ILI9341_D15_PORT, & GPIO_InitStructure );
    157. 	
    158.  
    159. 	
    160. 	/* 配置FSMC相对应的控制线
    161. 	 * FSMC_NOE   :LCD-RD
    162. 	 * FSMC_NWE   :LCD-WR
    163. 	 * FSMC_NE1   :LCD-CS
    164. 	 * FSMC_A16  	:LCD-DC
    165. 	 */
    166. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    167. 	GPIO_InitStructure.GPIO_Mode =  GPIO_Mode_AF_PP;
    168. 	
    169. 	GPIO_InitStructure.GPIO_Pin = ILI9341_RD_PIN; 
    170. 	GPIO_Init (ILI9341_RD_PORT, & GPIO_InitStructure );
    171. 	
    172. 	GPIO_InitStructure.GPIO_Pin = ILI9341_WR_PIN; 
    173. 	GPIO_Init (ILI9341_WR_PORT, & GPIO_InitStructure );
    174. 	
    175. 	GPIO_InitStructure.GPIO_Pin = ILI9341_CS_PIN; 
    176. 	GPIO_Init ( ILI9341_CS_PORT, & GPIO_InitStructure );  
    177. 	
    178. 	GPIO_InitStructure.GPIO_Pin = ILI9341_DC_PIN; 
    179. 	GPIO_Init ( ILI9341_DC_PORT, & GPIO_InitStructure );
    180. 	
    181.  
    182.   /* 配置LCD复位RST控制管脚*/
    183. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    184. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    185. 	
    186. 	GPIO_InitStructure.GPIO_Pin = ILI9341_RST_PIN; 
    187. 	GPIO_Init ( ILI9341_RST_PORT, & GPIO_InitStructure );
    188. 	
    189. 	
    190. 	/* 配置LCD背光控制管脚BK*/
    191. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    192. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
    193. 	
    194. 	GPIO_InitStructure.GPIO_Pin = ILI9341_BK_PIN; 
    195. 	GPIO_Init ( ILI9341_BK_PORT, & GPIO_InitStructure );
    196. }
    197.  
    198.  
    199.  /**
    200.   * @brief  LCD  FSMC 模式配置
    201.   * @param  无
    202.   * @retval 无
    203.   */
    204. static void ILI9341_FSMC_Config ( void )
    205. {
    206. 	FSMC_NORSRAMInitTypeDef  FSMC_NORSRAMInitStructure;
    207. 	FSMC_NORSRAMTimingInitTypeDef  readWriteTiming; 	
    208. 	
    209. 	/* 使能FSMC时钟*/
    210. 	RCC_AHBPeriphClockCmd ( RCC_AHBPeriph_FSMC, ENABLE );
    211.  
    212. 	//地址建立时间（ADDSET）为1个HCLK 2/72M=28ns
    213. 	readWriteTiming.FSMC_AddressSetupTime      = 0x01;	 //地址建立时间
    214. 	//数据保持时间（DATAST）+ 1个HCLK = 5/72M=70ns	
    215. 	readWriteTiming.FSMC_DataSetupTime         = 0x04;	 //数据建立时间
    216. 	//选择控制的模式
    217. 	//模式B,异步NOR FLASH模式，与ILI9341的8080时序匹配
    218. 	readWriteTiming.FSMC_AccessMode            = FSMC_AccessMode_B;	
    219. 	
    220. 	/*以下配置与模式B无关*/
    221. 	//地址保持时间（ADDHLD）模式A未用到
    222. 	readWriteTiming.FSMC_AddressHoldTime       = 0x00;	 //地址保持时间
    223. 	//设置总线转换周期，仅用于复用模式的NOR操作
    224. 	readWriteTiming.FSMC_BusTurnAroundDuration = 0x00;
    225. 	//设置时钟分频，仅用于同步类型的存储器
    226. 	readWriteTiming.FSMC_CLKDivision           = 0x00;
    227. 	//数据保持时间，仅用于同步型的NOR	
    228. 	readWriteTiming.FSMC_DataLatency           = 0x00;	
    229.  
    230. 	FSMC_NORSRAMInitStructure.FSMC_AsynchronousWait		  =FSMC_AsynchronousWait_Disable;
    231. 	FSMC_NORSRAMInitStructure.FSMC_Bank                  = FSMC_Bank1_NORSRAMx;
    232. 	FSMC_NORSRAMInitStructure.FSMC_DataAddressMux        = FSMC_DataAddressMux_Disable;
    233. 	FSMC_NORSRAMInitStructure.FSMC_MemoryType            = FSMC_MemoryType_NOR;
    234. 	FSMC_NORSRAMInitStructure.FSMC_MemoryDataWidth       = FSMC_MemoryDataWidth_16b;
    235. 	FSMC_NORSRAMInitStructure.FSMC_BurstAccessMode       = FSMC_BurstAccessMode_Disable;
    236. 	FSMC_NORSRAMInitStructure.FSMC_WaitSignalPolarity    = FSMC_WaitSignalPolarity_Low;
    237. 	FSMC_NORSRAMInitStructure.FSMC_WrapMode              = FSMC_WrapMode_Disable;
    238. 	FSMC_NORSRAMInitStructure.FSMC_WaitSignalActive      = FSMC_WaitSignalActive_BeforeWaitState;
    239. 	FSMC_NORSRAMInitStructure.FSMC_WriteOperation        = FSMC_WriteOperation_Enable;
    240. 	FSMC_NORSRAMInitStructure.FSMC_WaitSignal            = FSMC_WaitSignal_Disable;
    241. 	FSMC_NORSRAMInitStructure.FSMC_ExtendedMode          = FSMC_ExtendedMode_Disable;
    242. 	FSMC_NORSRAMInitStructure.FSMC_WriteBurst            = FSMC_WriteBurst_Disable;
    243. 	FSMC_NORSRAMInitStructure.FSMC_ReadWriteTimingStruct = &readWriteTiming;
    244. 	FSMC_NORSRAMInitStructure.FSMC_WriteTimingStruct     = &readWriteTiming;  
    245. 	
    246. 	FSMC_NORSRAMInit ( & FSMC_NORSRAMInitStructure ); 
    247. 	
    248. 	
    249. 	/* 使能 FSMC_Bank1_NORSRAM4 */
    250. 	FSMC_NORSRAMCmd ( FSMC_Bank1_NORSRAMx, ENABLE );  
    251. 		
    252. 		
    253. }
    254.  
    255.  
    256. /**
    257.  * @brief  初始化ILI9341寄存器
    258.  * @param  无
    259.  * @retval 无
    260.  */
    261. static void ILI9341_REG_Config ( void )
    262. {
    263. 	/*  Power control B (CFh)  */
    264. 	DEBUG_DELAY  ();
    265. 	ILI9341_Write_Cmd ( 0xCF  );
    266. 	ILI9341_Write_Data ( 0x00  );
    267. 	ILI9341_Write_Data ( 0x81  );
    268. 	ILI9341_Write_Data ( 0x30  );
    269. 	
    270. 	/*  Power on sequence control (EDh) */
    271. 	DEBUG_DELAY ();
    272. 	ILI9341_Write_Cmd ( 0xED );
    273. 	ILI9341_Write_Data ( 0x64 );
    274. 	ILI9341_Write_Data ( 0x03 );
    275. 	ILI9341_Write_Data ( 0x12 );
    276. 	ILI9341_Write_Data ( 0x81 );
    277. 	
    278. 	/*  Driver timing control A (E8h) */
    279. 	DEBUG_DELAY ();
    280. 	ILI9341_Write_Cmd ( 0xE8 );
    281. 	ILI9341_Write_Data ( 0x85 );
    282. 	ILI9341_Write_Data ( 0x10 );
    283. 	ILI9341_Write_Data ( 0x78 );
    284. 	
    285. 	/*  Power control A (CBh) */
    286. 	DEBUG_DELAY ();
    287. 	ILI9341_Write_Cmd ( 0xCB );
    288. 	ILI9341_Write_Data ( 0x39 );
    289. 	ILI9341_Write_Data ( 0x2C );
    290. 	ILI9341_Write_Data ( 0x00 );
    291. 	ILI9341_Write_Data ( 0x34 );
    292. 	ILI9341_Write_Data ( 0x02 );
    293. 	
    294. 	/* Pump ratio control (F7h) */
    295. 	DEBUG_DELAY ();
    296. 	ILI9341_Write_Cmd ( 0xF7 );
    297. 	ILI9341_Write_Data ( 0x20 );
    298. 	
    299. 	/* Driver timing control B */
    300. 	DEBUG_DELAY ();
    301. 	ILI9341_Write_Cmd ( 0xEA );
    302. 	ILI9341_Write_Data ( 0x00 );
    303. 	ILI9341_Write_Data ( 0x00 );
    304. 	
    305. 	/* Frame Rate Control (In Normal Mode/Full Colors) (B1h) */
    306. 	DEBUG_DELAY ();
    307. 	ILI9341_Write_Cmd ( 0xB1 );
    308. 	ILI9341_Write_Data ( 0x00 );
    309. 	ILI9341_Write_Data ( 0x1B );
    310. 	
    311. 	/*  Display Function Control (B6h) */
    312. 	DEBUG_DELAY ();
    313. 	ILI9341_Write_Cmd ( 0xB6 );
    314. 	ILI9341_Write_Data ( 0x0A );
    315. 	ILI9341_Write_Data ( 0xA2 );
    316. 	
    317. 	/* Power Control 1 (C0h) */
    318. 	DEBUG_DELAY ();
    319. 	ILI9341_Write_Cmd ( 0xC0 );
    320. 	ILI9341_Write_Data ( 0x35 );
    321. 	
    322. 	/* Power Control 2 (C1h) */
    323. 	DEBUG_DELAY ();
    324. 	ILI9341_Write_Cmd ( 0xC1 );
    325. 	ILI9341_Write_Data ( 0x11 );
    326. 	
    327. 	/* VCOM Control 1 (C5h) */
    328. 	ILI9341_Write_Cmd ( 0xC5 );
    329. 	ILI9341_Write_Data ( 0x45 );
    330. 	ILI9341_Write_Data ( 0x45 );
    331. 	
    332. 	/*  VCOM Control 2 (C7h)  */
    333. 	ILI9341_Write_Cmd ( 0xC7 );
    334. 	ILI9341_Write_Data ( 0xA2 );
    335. 	
    336. 	/* Enable 3G (F2h) */
    337. 	ILI9341_Write_Cmd ( 0xF2 );
    338. 	ILI9341_Write_Data ( 0x00 );
    339. 	
    340. 	/* Gamma Set (26h) */
    341. 	ILI9341_Write_Cmd ( 0x26 );
    342. 	ILI9341_Write_Data ( 0x01 );
    343. 	DEBUG_DELAY ();
    344. 	
    345. 	/* Positive Gamma Correction */
    346. 	ILI9341_Write_Cmd ( 0xE0 ); //Set Gamma
    347. 	ILI9341_Write_Data ( 0x0F );
    348. 	ILI9341_Write_Data ( 0x26 );
    349. 	ILI9341_Write_Data ( 0x24 );
    350. 	ILI9341_Write_Data ( 0x0B );
    351. 	ILI9341_Write_Data ( 0x0E );
    352. 	ILI9341_Write_Data ( 0x09 );
    353. 	ILI9341_Write_Data ( 0x54 );
    354. 	ILI9341_Write_Data ( 0xA8 );
    355. 	ILI9341_Write_Data ( 0x46 );
    356. 	ILI9341_Write_Data ( 0x0C );
    357. 	ILI9341_Write_Data ( 0x17 );
    358. 	ILI9341_Write_Data ( 0x09 );
    359. 	ILI9341_Write_Data ( 0x0F );
    360. 	ILI9341_Write_Data ( 0x07 );
    361. 	ILI9341_Write_Data ( 0x00 );
    362. 	
    363. 	/* Negative Gamma Correction (E1h) */
    364. 	ILI9341_Write_Cmd ( 0XE1 ); //Set Gamma
    365. 	ILI9341_Write_Data ( 0x00 );
    366. 	ILI9341_Write_Data ( 0x19 );
    367. 	ILI9341_Write_Data ( 0x1B );
    368. 	ILI9341_Write_Data ( 0x04 );
    369. 	ILI9341_Write_Data ( 0x10 );
    370. 	ILI9341_Write_Data ( 0x07 );
    371. 	ILI9341_Write_Data ( 0x2A );
    372. 	ILI9341_Write_Data ( 0x47 );
    373. 	ILI9341_Write_Data ( 0x39 );
    374. 	ILI9341_Write_Data ( 0x03 );
    375. 	ILI9341_Write_Data ( 0x06 );
    376. 	ILI9341_Write_Data ( 0x06 );
    377. 	ILI9341_Write_Data ( 0x30 );
    378. 	ILI9341_Write_Data ( 0x38 );
    379. 	ILI9341_Write_Data ( 0x0F );
    380. 	
    381. 	/* memory access control set */
    382. 	DEBUG_DELAY ();
    383. 	ILI9341_Write_Cmd ( 0x36 ); 	
    384. 	ILI9341_Write_Data ( 0xC8 );    /*竖屏  左上角到 (起点)到右下角 (终点)扫描方式*/
    385. 	DEBUG_DELAY ();
    386. 	
    387. 	/* column address control set */
    388. 	ILI9341_Write_Cmd ( CMD_SetCoordinateX ); 
    389. 	ILI9341_Write_Data ( 0x00 );
    390. 	ILI9341_Write_Data ( 0x00 );
    391. 	ILI9341_Write_Data ( 0x00 );
    392. 	ILI9341_Write_Data ( 0xEF );
    393. 	
    394. 	/* page address control set */
    395. 	DEBUG_DELAY ();
    396. 	ILI9341_Write_Cmd ( CMD_SetCoordinateY ); 
    397. 	ILI9341_Write_Data ( 0x00 );
    398. 	ILI9341_Write_Data ( 0x00 );
    399. 	ILI9341_Write_Data ( 0x01 );
    400. 	ILI9341_Write_Data ( 0x3F );
    401. 	
    402. 	/*  Pixel Format Set (3Ah)  */
    403. 	DEBUG_DELAY ();
    404. 	ILI9341_Write_Cmd ( 0x3a ); 
    405. 	ILI9341_Write_Data ( 0x55 );
    406. 	
    407. 	/* Sleep Out (11h)  */
    408. 	ILI9341_Write_Cmd ( 0x11 );	
    409. 	ILI9341_Delay ( 0xAFFf<<2 );
    410. 	DEBUG_DELAY ();
    411. 	
    412. 	/* Display ON (29h) */
    413. 	ILI9341_Write_Cmd ( 0x29 ); 
    414. 	
    415. 	
    416. }
    417.  
    418.  
    419. /**
    420.  * @brief  ILI9341初始化函数，如果要用到lcd，一定要调用这个函数
    421.  * @param  无
    422.  * @retval 无
    423.  */
    424. void ILI9341_Init ( void )
    425. {
    426. 	ILI9341_GPIO_Config ();
    427. 	ILI9341_FSMC_Config ();
    428. 	
    429. 	ILI9341_BackLed_Control ( ENABLE );      //点亮LCD背光灯
    430. 	ILI9341_Rst ();
    431. 	ILI9341_REG_Config ();
    432. 	
    433. 	//设置默认扫描方向，其中 6 模式为大部分液晶例程的默认显示方向  
    434. 	ILI9341_GramScan(LCD_SCAN_MODE);
    435. }
    436.  
    437.  
    438. /**
    439.  * @brief  ILI9341背光LED控制
    440.  * @param  enumState ：决定是否使能背光LED
    441.   *   该参数为以下值之一：
    442.   *     @arg ENABLE :使能背光LED
    443.   *     @arg DISABLE :禁用背光LED
    444.  * @retval 无
    445.  */
    446. void ILI9341_BackLed_Control ( FunctionalState enumState )
    447. {
    448. 	if ( enumState )
    449. 		GPIO_ResetBits ( ILI9341_BK_PORT, ILI9341_BK_PIN );	
    450. 	else
    451. 		GPIO_SetBits ( ILI9341_BK_PORT, ILI9341_BK_PIN );
    452. 		
    453. }
    454.  
    455.  
    456.  
    457. /**
    458.  * @brief  ILI9341 软件复位
    459.  * @param  无
    460.  * @retval 无
    461.  */
    462. void ILI9341_Rst ( void )
    463. {			
    464. 	GPIO_ResetBits ( ILI9341_RST_PORT, ILI9341_RST_PIN );	 //低电平复位
    465.  
    466. 	ILI9341_Delay ( 0xAFF ); 					   
    467.  
    468. 	GPIO_SetBits ( ILI9341_RST_PORT, ILI9341_RST_PIN );		 	 
    469.  
    470. 	ILI9341_Delay ( 0xAFF ); 	
    471. 	
    472. }
    473.  
    474.  
    475.  
    476.  
    477. /**
    478.  * @brief  设置ILI9341的GRAM的扫描方向 
    479.  * @param  ucOption ：选择GRAM的扫描方向 
    480.  *     @arg 0-7 :参数可选值为0-7这八个方向
    481.  *
    482.  *	！！！其中0、3、5、6 模式适合从左至右显示文字，
    483.  *				不推荐使用其它模式显示文字	其它模式显示文字会有镜像效果			
    484.  *		
    485.  *	其中0、2、4、6 模式的X方向像素为240，Y方向像素为320
    486.  *	其中1、3、5、7 模式下X方向像素为320，Y方向像素为240
    487.  *
    488.  *	其中 6 模式为大部分液晶例程的默认显示方向
    489.  *	其中 3 模式为摄像头例程使用的方向
    490.  *	其中 0 模式为BMP图片显示例程使用的方向
    491.  *
    492.  * @retval 无
    493.  * @note  坐标图例：A表示向上，V表示向下，<表示向左，>表示向右
    494. 					X表示X轴，Y表示Y轴
    496. ------------------------------------------------------------
    497. 模式0：				.		模式1：		.	模式2：			.	模式3：					
    498. 					A		.					A		.		A					.		A									
    499. 					|		.					|		.		|					.		|							
    500. 					Y		.					X		.		Y					.		X					
    501. 					0		.					1		.		2					.		3					
    502. 	<--- X0 o		.	<----Y1	o		.		o 2X--->  .		o 3Y--->	
    503. ------------------------------------------------------------	
    504. 模式4：				.	模式5：			.	模式6：			.	模式7：					
    505. 	<--- X4 o		.	<--- Y5 o		.		o 6X--->  .		o 7Y--->	
    506. 					4		.					5		.		6					.		7	
    507. 					Y		.					X		.		Y					.		X						
    508. 					|		.					|		.		|					.		|							
    509. 					V		.					V		.		V					.		V		
    510. ---------------------------------------------------------				
    511. 											 LCD屏示例
    512. 								|-----------------|
    513. 								|			秉火Logo		|
    514. 								|									|
    515. 								|									|
    516. 								|									|
    517. 								|									|
    518. 								|									|
    519. 								|									|
    520. 								|									|
    521. 								|									|
    522. 								|-----------------|
    523. 								屏幕正面（宽240，高320）
    525.  *******************************************************/
    526. void ILI9341_GramScan ( uint8_t ucOption )
    527. {	
    528. 	//参数检查，只可输入0-7
    529. 	if(ucOption >7 )
    530. 		return;
    531. 	
    532. 	//根据模式更新LCD_SCAN_MODE的值，主要用于触摸屏选择计算参数
    533. 	LCD_SCAN_MODE = ucOption;
    534. 	
    535. 	//根据模式更新XY方向的像素宽度
    536. 	if(ucOption%2 == 0)	
    537. 	{
    538. 		//0 2 4 6模式下X方向像素宽度为240，Y方向为320
    539. 		LCD_X_LENGTH = ILI9341_LESS_PIXEL;
    540. 		LCD_Y_LENGTH =	ILI9341_MORE_PIXEL;
    541. 	}
    542. 	else				
    543. 	{
    544. 		//1 3 5 7模式下X方向像素宽度为320，Y方向为240
    545. 		LCD_X_LENGTH = ILI9341_MORE_PIXEL;
    546. 		LCD_Y_LENGTH =	ILI9341_LESS_PIXEL; 
    547. 	}
    548.  
    549. 	//0x36命令参数的高3位可用于设置GRAM扫描方向	
    550. 	ILI9341_Write_Cmd ( 0x36 ); 
    551. 	ILI9341_Write_Data ( 0x08 |(ucOption<<5));//根据ucOption的值设置LCD参数，共0-7种模式
    552. 	ILI9341_Write_Cmd ( CMD_SetCoordinateX ); 
    553. 	ILI9341_Write_Data ( 0x00 );		/* x 起始坐标高8位 */
    554. 	ILI9341_Write_Data ( 0x00 );		/* x 起始坐标低8位 */
    555. 	ILI9341_Write_Data ( ((LCD_X_LENGTH-1)>>8)&0xFF ); /* x 结束坐标高8位 */	
    556. 	ILI9341_Write_Data ( (LCD_X_LENGTH-1)&0xFF );				/* x 结束坐标低8位 */
    557.  
    558. 	ILI9341_Write_Cmd ( CMD_SetCoordinateY ); 
    559. 	ILI9341_Write_Data ( 0x00 );		/* y 起始坐标高8位 */
    560. 	ILI9341_Write_Data ( 0x00 );		/* y 起始坐标低8位 */
    561. 	ILI9341_Write_Data ( ((LCD_Y_LENGTH-1)>>8)&0xFF );	/* y 结束坐标高8位 */	 
    562. 	ILI9341_Write_Data ( (LCD_Y_LENGTH-1)&0xFF );				/* y 结束坐标低8位 */
    563.  
    564. 	/* write gram start */
    565. 	ILI9341_Write_Cmd ( CMD_SetPixel );	
    566. }
    567.  
    568.  
    569.  
    570. /**
    571.  * @brief  在ILI9341显示器上开辟一个窗口
    572.  * @param  usX ：在特定扫描方向下窗口的起点X坐标
    573.  * @param  usY ：在特定扫描方向下窗口的起点Y坐标
    574.  * @param  usWidth ：窗口的宽度
    575.  * @param  usHeight ：窗口的高度
    576.  * @retval 无
    577.  */
    578. void ILI9341_OpenWindow ( uint16_t usX, uint16_t usY, uint16_t usWidth, uint16_t usHeight )
    579. {	
    580. 	ILI9341_Write_Cmd ( CMD_SetCoordinateX ); 				 /* 设置X坐标 */
    581. 	ILI9341_Write_Data ( usX >> 8  );	 /* 先高8位，然后低8位 */
    582. 	ILI9341_Write_Data ( usX & 0xff  );	 /* 设置起始点和结束点*/
    583. 	ILI9341_Write_Data ( ( usX + usWidth - 1 ) >> 8  );
    584. 	ILI9341_Write_Data ( ( usX + usWidth - 1 ) & 0xff  );
    585.  
    586. 	ILI9341_Write_Cmd ( CMD_SetCoordinateY ); 			     /* 设置Y坐标*/
    587. 	ILI9341_Write_Data ( usY >> 8  );
    588. 	ILI9341_Write_Data ( usY & 0xff  );
    589. 	ILI9341_Write_Data ( ( usY + usHeight - 1 ) >> 8 );
    590. 	ILI9341_Write_Data ( ( usY + usHeight - 1) & 0xff );
    591. 	
    592. }
    593.  
    594.  
    595. /**
    596.  * @brief  设定ILI9341的光标坐标
    597.  * @param  usX ：在特定扫描方向下光标的X坐标
    598.  * @param  usY ：在特定扫描方向下光标的Y坐标
    599.  * @retval 无
    600.  */
    601. static void ILI9341_SetCursor ( uint16_t usX, uint16_t usY )	
    602. {
    603. 	ILI9341_OpenWindow ( usX, usY, 1, 1 );
    604. }
    605.  
    606.  
    607. /**
    608.  * @brief  在ILI9341显示器上以某一颜色填充像素点
    609.  * @param  ulAmout_Point ：要填充颜色的像素点的总数目
    610.  * @param  usColor ：颜色
    611.  * @retval 无
    612.  */
    613. static __inline void ILI9341_FillColor ( uint32_t ulAmout_Point, uint16_t usColor )
    614. {
    615. 	uint32_t i = 0;
    616. 	
    617. 	
    618. 	/* memory write */
    619. 	ILI9341_Write_Cmd ( CMD_SetPixel );	
    620. 		
    621. 	for ( i = 0; i < ulAmout_Point; i ++ )
    622. 		ILI9341_Write_Data ( usColor );
    623. 		
    624. 	
    625. }
    626.  
    627.  
    628. /**
    629.  * @brief  对ILI9341显示器的某一窗口以某种颜色进行清屏
    630.  * @param  usX ：在特定扫描方向下窗口的起点X坐标
    631.  * @param  usY ：在特定扫描方向下窗口的起点Y坐标
    632.  * @param  usWidth ：窗口的宽度
    633.  * @param  usHeight ：窗口的高度
    634.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    635.  * @retval 无
    636.  */
    637. void ILI9341_Clear ( uint16_t usX, uint16_t usY, uint16_t usWidth, uint16_t usHeight )
    638. {
    639. 	ILI9341_OpenWindow ( usX, usY, usWidth, usHeight );
    640.  
    641. 	ILI9341_FillColor ( usWidth * usHeight, CurrentBackColor );		
    642. 	
    643. }
    644.  
    645.  
    646. /**
    647.  * @brief  对ILI9341显示器的某一点以某种颜色进行填充
    648.  * @param  usX ：在特定扫描方向下该点的X坐标
    649.  * @param  usY ：在特定扫描方向下该点的Y坐标
    650.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    651.  * @retval 无
    652.  */
    653. void ILI9341_SetPointPixel ( uint16_t usX, uint16_t usY )	
    654. {	
    655. 	if ( ( usX < LCD_X_LENGTH ) && ( usY < LCD_Y_LENGTH ))
    656.   {
    657. 		ILI9341_SetCursor ( usX, usY );
    658. 		
    659. 		ILI9341_FillColor ( 1, CYAN );
    660. 	}
    661. 	
    662. }
    663.  
    664.  
    665. /**
    666.  * @brief  对ILI9341显示器的某一点以某种颜色进行填充
    667.  * @param  usX ：在特定扫描方向下该点的X坐标
    668.  * @param  usY ：在特定扫描方向下该点的Y坐标
    669.  * @param  fill：0和1选择填充前景色或背景色
    670.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    671.  * @retval 无
    672.  */
    673. void ILI9341_SetPointPixel_Fill ( uint16_t usX, uint16_t usY ,uint8_t fill)	
    674. {	
    675. 	if ( ( usX < LCD_X_LENGTH ) && ( usY < LCD_Y_LENGTH )&& fill)
    676.   {
    677. 		ILI9341_SetCursor ( usX, usY );
    678. 		
    679. 		ILI9341_FillColor ( 1, CurrentTextColor );
    680. 	}
    681. 	else
    682. 	{
    683. 		ILI9341_SetCursor ( usX, usY );
    684. 		
    685. 		ILI9341_FillColor ( 1, CurrentBackColor );
    686. 	}
    687. 	
    688. }
    689.  
    690.  
    691. /**
    692.  * @brief  对ILI9341显示器的某一点以某种颜色进行填充
    693.  * @param  usX ：在特定扫描方向下该点的X坐标
    694.  * @param  usY ：在特定扫描方向下该点的Y坐标
    695.  * @param  color：选择某种颜色进行填充
    696.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    697.  * @retval 无
    698.  */
    699. void ILI9341_SetPointPixel_Color ( uint16_t usX, uint16_t usY ,uint16_t color)	
    700. {	
    701. 	if ( ( usX < LCD_X_LENGTH ) && ( usY < LCD_Y_LENGTH ))
    702.   {
    703. 		ILI9341_SetCursor ( usX, usY );
    704. 		
    705. 		ILI9341_FillColor ( 1, color );
    706. 	}
    707. 	
    708. }
    709. /**
    710.  * @brief  读取ILI9341 GRAN 的一个像素数据
    711.  * @param  无
    712.  * @retval 像素数据
    713.  */
    714. static uint16_t ILI9341_Read_PixelData ( void )	
    715. {	
    716. 	uint16_t usR=0, usG=0, usB=0 ;
    717.  
    718. 	
    719. 	ILI9341_Write_Cmd ( 0x2E );   /* 读数据 */
    720. 	
    721. 	usR = ILI9341_Read_Data (); 	/*FIRST READ OUT DUMMY DATA*/
    722. 	
    723. 	usR = ILI9341_Read_Data ();  	/*READ OUT RED DATA  */
    724. 	usB = ILI9341_Read_Data ();  	/*READ OUT BLUE DATA*/
    725. 	usG = ILI9341_Read_Data ();  	/*READ OUT GREEN DATA*/	
    726. 	
    727.   return ( ( ( usR >> 11 ) << 11 ) | ( ( usG >> 10 ) << 5 ) | ( usB >> 11 ) );
    728. 	
    729. }
    730.  
    731.  
    732. /**
    733.  * @brief  获取 ILI9341 显示器上某一个坐标点的像素数据
    734.  * @param  usX ：在特定扫描方向下该点的X坐标
    735.  * @param  usY ：在特定扫描方向下该点的Y坐标
    736.  * @retval 像素数据
    737.  */
    738. uint16_t ILI9341_GetPointPixel ( uint16_t usX, uint16_t usY )
    739. { 
    740. 	uint16_t usPixelData;
    741.  
    742. 	
    743. 	ILI9341_SetCursor ( usX, usY );
    744. 	
    745. 	usPixelData = ILI9341_Read_PixelData ();
    746. 	
    747. 	return usPixelData;
    748. 	
    749. }
    750.  
    751.  
    752. /**
    753.  * @brief  在 ILI9341 显示器上使用 Bresenham 算法画线段 
    754.  * @param  usX1 ：在特定扫描方向下线段的一个端点X坐标
    755.  * @param  usY1 ：在特定扫描方向下线段的一个端点Y坐标
    756.  * @param  usX2 ：在特定扫描方向下线段的另一个端点X坐标
    757.  * @param  usY2 ：在特定扫描方向下线段的另一个端点Y坐标
    758.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    759.  * @retval 无
    760.  */
    761. void ILI9341_DrawLine ( uint16_t usX1, uint16_t usY1, uint16_t usX2, uint16_t usY2 )
    762. {
    763. 	uint16_t us; 
    764. 	uint16_t usX_Current, usY_Current;
    765. 	
    766. 	int32_t lError_X = 0, lError_Y = 0, lDelta_X, lDelta_Y, lDistance; 
    767. 	int32_t lIncrease_X, lIncrease_Y; 	
    768. 	
    769. 	
    770. 	lDelta_X = usX2 - usX1; //计算坐标增量 
    771. 	lDelta_Y = usY2 - usY1; 
    772. 	
    773. 	usX_Current = usX1; 
    774. 	usY_Current = usY1; 
    775. 	
    776. 	
    777. 	if ( lDelta_X > 0 ) 
    778. 		lIncrease_X = 1; //设置单步方向 
    779. 	
    780. 	else if ( lDelta_X == 0 ) 
    781. 		lIncrease_X = 0;//垂直线 
    782. 	
    783. 	else 
    784.   { 
    785.     lIncrease_X = -1;
    786.     lDelta_X = - lDelta_X;
    787.   } 
    788.  
    789. 	
    790. 	if ( lDelta_Y > 0 )
    791. 		lIncrease_Y = 1; 
    792. 	
    793. 	else if ( lDelta_Y == 0 )
    794. 		lIncrease_Y = 0;//水平线 
    795. 	
    796. 	else 
    797.   {
    798.     lIncrease_Y = -1;
    799.     lDelta_Y = - lDelta_Y;
    800.   } 
    801.  
    802. 	
    803. 	if (  lDelta_X > lDelta_Y )
    804. 		lDistance = lDelta_X; //选取基本增量坐标轴 
    805. 	
    806. 	else 
    807. 		lDistance = lDelta_Y; 
    808.  
    809. 	
    810. 	for ( us = 0; us <= lDistance + 1; us ++ )//画线输出 
    811. 	{  
    812. 		ILI9341_SetPointPixel ( usX_Current, usY_Current );//画点 
    813. 		
    814. 		lError_X += lDelta_X ; 
    815. 		lError_Y += lDelta_Y ; 
    816. 		
    817. 		if ( lError_X > lDistance ) 
    818. 		{ 
    819. 			lError_X -= lDistance; 
    820. 			usX_Current += lIncrease_X; 
    821. 		}  
    822. 		
    823. 		if ( lError_Y > lDistance ) 
    824. 		{ 
    825. 			lError_Y -= lDistance; 
    826. 			usY_Current += lIncrease_Y; 
    827. 		} 
    828. 		
    829. 	}  
    830. 	
    831. 	
    832. }   
    833.  
    834.  
    835. /*
    836. 函数功能：任意角度画直线 
    837. 参    数：
    838. 	usX,usY:坐标
    839. 	usAngle :度数
    840. 	usRadius:半径
    841. 	usLength  :线段的长度
    842. 	c  :颜色值 0或者1
    843. 例如:ILI9341_DrawAngleLine(60,30,45,20,20,1);//角度画线
    844. */
    845. void 	ILI9341_DrawAngleLine( uint32_t usX, uint32_t usY, float usAngle, uint32_t usRadius, uint32_t usLength,uint16_t color)
    846. {
    847. 	int i;
    848. 	int x0,y0;
    849. 	double k=usAngle*(3.1415926535/180);	
    850. 	for(i=usRadius;i
    851. 	{
    852. 		x0=cos(k)*i;
    853. 		y0=sin(k)*i;
    854. 		ILI9341_SetPointPixel_Color(usX+x0,usY+y0,color);
    855. 	}
    856. }
    857.  
    858.  
    859.  
    860.  
    861. /*
    862. 函数功能：任意角度画直线 
    863. 参    数：
    864. 	usX,usY:坐标
    865. 	usRadius :度数
    866. 	usLength :线段的长度
    867. 	c  :颜色值 0或者1
    868. 例如:OLED_DrawAngleLine(60,30,45,20,20,1);//角度画线
    869. */
    870. void 	ILI9341_DrawAngleLine2( uint32_t usX, uint32_t usY,float usAngle,uint32_t usRadius,uint32_t usLength,uint8_t fill)
    871. {
    872. 	uint32_t i;
    873. 	int x0,y0;
    874. 	double k=usAngle*(3.1415926535L/180);
    875.    
    876. 	for(i=usRadius;i
    877. 	{
    878. 		x0=cos(k)*i;
    879. 		y0=sin(k)*i;
    880. 		ILI9341_SetPointPixel_Fill(usX+x0,usY+y0,fill);
    881. 	}
    882. }
    883.  
    884.  
    885. /**
    886.  * @brief  在 ILI9341 显示器上画一个矩形
    887.  * @param  usX_Start ：在特定扫描方向下矩形的起始点X坐标
    888.  * @param  usY_Start ：在特定扫描方向下矩形的起始点Y坐标
    889.  * @param  usWidth：矩形的宽度（单位：像素）
    890.  * @param  usHeight：矩形的高度（单位：像素）
    891.  * @param  ucFilled ：选择是否填充该矩形
    892.   *   该参数为以下值之一：
    893.   *     @arg 0 :空心矩形
    894.   *     @arg 1 :实心矩形 
    895.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    896.  * @retval 无
    897.  */
    898. void ILI9341_DrawRectangle ( uint16_t usX_Start, uint16_t usY_Start, uint16_t usWidth, uint16_t usHeight, uint8_t ucFilled )
    899. {
    900. 	if ( ucFilled )
    901. 	{
    902. 		ILI9341_OpenWindow ( usX_Start, usY_Start, usWidth, usHeight );
    903. 		ILI9341_FillColor ( usWidth * usHeight ,CurrentTextColor);	
    904. 	}
    905. 	else
    906. 	{
    907. 		ILI9341_DrawLine ( usX_Start, usY_Start, usX_Start + usWidth - 1, usY_Start );
    908. 		ILI9341_DrawLine ( usX_Start, usY_Start + usHeight - 1, usX_Start + usWidth - 1, usY_Start + usHeight - 1 );
    909. 		ILI9341_DrawLine ( usX_Start, usY_Start, usX_Start, usY_Start + usHeight - 1 );
    910. 		ILI9341_DrawLine ( usX_Start + usWidth - 1, usY_Start, usX_Start + usWidth - 1, usY_Start + usHeight - 1 );		
    911. 	}
    912.  
    913. }
    914.  
    915.  
    916. /**
    917.  * @brief  在 ILI9341 显示器上使用 Bresenham 算法画圆
    918.  * @param  usX_Center ：在特定扫描方向下圆心的X坐标
    919.  * @param  usY_Center ：在特定扫描方向下圆心的Y坐标
    920.  * @param  usRadius：圆的半径（单位：像素）
    921.  * @param  ucFilled ：选择是否填充该圆
    922.   *   该参数为以下值之一：
    923.   *     @arg 0 :空心圆
    924.   *     @arg 1 :实心圆
    925.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    926.  * @retval 无
    927.  */
    928. void ILI9341_DrawCircle ( uint16_t usX_Center, uint16_t usY_Center, uint16_t usRadius, uint8_t ucFilled )
    929. {
    930. 	int16_t sCurrentX, sCurrentY;
    931. 	int16_t sError;
    932. 	
    933. 	
    934. 	sCurrentX = 0; sCurrentY = usRadius;	  
    935. 	
    936. 	sError = 3 - ( usRadius << 1 );     //判断下个点位置的标志
    937. 	
    938. 	
    939. 	while ( sCurrentX <= sCurrentY )
    940. 	{
    941. 		int16_t sCountY;
    942. 		
    943. 		
    944. 		if ( ucFilled ) 			
    945. 			for ( sCountY = sCurrentX; sCountY <= sCurrentY; sCountY ++ ) 
    946. 			{                      
    947. 				ILI9341_SetPointPixel ( usX_Center + sCurrentX, usY_Center + sCountY );           //1，研究对象 
    948. 				ILI9341_SetPointPixel ( usX_Center - sCurrentX, usY_Center + sCountY );           //2       
    949. 				ILI9341_SetPointPixel ( usX_Center - sCountY,   usY_Center + sCurrentX );           //3
    950. 				ILI9341_SetPointPixel ( usX_Center - sCountY,   usY_Center - sCurrentX );           //4
    951. 				ILI9341_SetPointPixel ( usX_Center - sCurrentX, usY_Center - sCountY );           //5    
    952. 				ILI9341_SetPointPixel ( usX_Center + sCurrentX, usY_Center - sCountY );           //6
    953. 				ILI9341_SetPointPixel ( usX_Center + sCountY,   usY_Center - sCurrentX );           //7 	
    954. 				ILI9341_SetPointPixel ( usX_Center + sCountY,   usY_Center + sCurrentX );           //0				
    955. 			}
    956. 		
    957. 		else
    958. 		{          
    959. 			ILI9341_SetPointPixel ( usX_Center + sCurrentX, usY_Center + sCurrentY );             //1，研究对象
    960. 			ILI9341_SetPointPixel ( usX_Center - sCurrentX, usY_Center + sCurrentY );             //2      
    961. 			ILI9341_SetPointPixel ( usX_Center - sCurrentY, usY_Center + sCurrentX );             //3
    962. 			ILI9341_SetPointPixel ( usX_Center - sCurrentY, usY_Center - sCurrentX );             //4
    963. 			ILI9341_SetPointPixel ( usX_Center - sCurrentX, usY_Center - sCurrentY );             //5       
    964. 			ILI9341_SetPointPixel ( usX_Center + sCurrentX, usY_Center - sCurrentY );             //6
    965. 			ILI9341_SetPointPixel ( usX_Center + sCurrentY, usY_Center - sCurrentX );             //7 
    966. 			ILI9341_SetPointPixel ( usX_Center + sCurrentY, usY_Center + sCurrentX );             //0
    967.     }			
    968. 		
    969. 		
    970. 		sCurrentX ++;
    971.  
    972. 		
    973. 		if ( sError < 0 ) 
    974. 			sError += 4 * sCurrentX + 6;	  
    975. 		
    976. 		else
    977. 		{
    978. 			sError += 10 + 4 * ( sCurrentX - sCurrentY );   
    979. 			sCurrentY --;
    980. 		} 	
    981. 		
    982. 		
    983. 	}
    984. 	
    985. 	
    986. }
    987.  
    988. /**
    989.  * @brief  在 ILI9341 显示器上显示一个英文字符
    990.  * @param  usX ：在特定扫描方向下字符的起始X坐标
    991.  * @param  usY ：在特定扫描方向下该点的起始Y坐标
    992.  * @param  cChar ：要显示的英文字符
    993.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    994.  * @retval 无
    995.  */
    996. void ILI9341_DispChar_EN ( uint16_t usX, uint16_t usY, const char cChar )
    997. {
    998. 	uint8_t  byteCount, bitCount,fontLength;	
    999. 	uint16_t ucRelativePositon;
    1000. 	uint8_t *Pfont;
    1001. 	
    1002. 	//对ascii码表偏移（字模表不包含ASCII表的前32个非图形符号）
    1003. 	ucRelativePositon = cChar - ' ';
    1004. 	
    1005. 	//每个字模的字节数
    1006. 	fontLength = (LCD_Currentfonts->Width*LCD_Currentfonts->Height)/8;
    1007. 		
    1008. 	//字模首地址
    1009. 	/*ascii码表偏移值乘以每个字模的字节数，求出字模的偏移位置*/
    1010. 	Pfont = (uint8_t *)&LCD_Currentfonts->table[ucRelativePositon * fontLength];
    1011. 	
    1012. 	//设置显示窗口
    1013. 	ILI9341_OpenWindow ( usX, usY, LCD_Currentfonts->Width, LCD_Currentfonts->Height);
    1014. 	
    1015. 	ILI9341_Write_Cmd ( CMD_SetPixel );			
    1016.  
    1017. 	//按字节读取字模数据
    1018. 	//由于前面直接设置了显示窗口，显示数据会自动换行
    1019. 	for ( byteCount = 0; byteCount < fontLength; byteCount++ )
    1020. 	{
    1021. 			//一位一位处理要显示的颜色
    1022. 			for ( bitCount = 0; bitCount < 8; bitCount++ )
    1023. 			{
    1024. 					if ( Pfont[byteCount] & (0x80>>bitCount) )
    1025. 						ILI9341_Write_Data ( CurrentTextColor );			
    1026. 					else
    1027. 						ILI9341_Write_Data ( CurrentBackColor );
    1028. 			}	
    1029. 	}	
    1030. }
    1031.  
    1032.  
    1033. /**
    1034.  * @brief  在 ILI9341 显示器上显示一个中文字符
    1035.  * @param  usX ：在特定扫描方向下字符的起始X坐标
    1036.  * @param  usY ：在特定扫描方向下字符的起始Y坐标
    1037.  * @param  usChar ：要显示的中文字符（国标码）
    1038.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    1039.  * @retval 无
    1040.  */ 
    1041. void ILI9341_DispChar_CH ( uint16_t usX, uint16_t usY, uint16_t usChar )
    1042. {
    1043. 	uint8_t rowCount, bitCount;
    1044. 	uint8_t ucBuffer [ WIDTH_CH_CHAR*HEIGHT_CH_CHAR/8 ];	
    1045.   uint16_t usTemp; 	
    1046.  
    1047. 	//设置显示窗口
    1048. 	ILI9341_OpenWindow ( usX, usY, WIDTH_CH_CHAR, HEIGHT_CH_CHAR );
    1049. 	
    1050. 	ILI9341_Write_Cmd ( CMD_SetPixel );
    1051. 	
    1052. 	//取字模数据  
    1053.   GetGBKCode ( ucBuffer, usChar );	
    1054. 	
    1055. 	for ( rowCount = 0; rowCount < HEIGHT_CH_CHAR; rowCount++ )
    1056. 	{
    1057.     /* 取出两个字节的数据，在lcd上即是一个汉字的一行 */
    1058. 		usTemp = ucBuffer [ rowCount * 2 ];
    1059. 		usTemp = ( usTemp << 8 );
    1060. 		usTemp |= ucBuffer [ rowCount * 2 + 1 ];
    1061. 		
    1062. 		for ( bitCount = 0; bitCount < WIDTH_CH_CHAR; bitCount ++ )
    1063. 		{			
    1064. 			if ( usTemp & ( 0x8000 >> bitCount ) )  //高位在前 
    1065. 			  ILI9341_Write_Data ( CurrentTextColor );				
    1066. 			else
    1067. 				ILI9341_Write_Data ( CurrentBackColor );			
    1068. 		}		
    1069. 	}
    1070. 	
    1071. }
    1072.  
    1073.  
    1074. /**
    1075.  * @brief  在 ILI9341 显示器上显示英文字符串
    1076.  * @param  line ：在特定扫描方向下字符串的起始Y坐标
    1077.   *   本参数可使用宏LINE(0)、LINE(1)等方式指定文字坐标，
    1078.   *   宏LINE(x)会根据当前选择的字体来计算Y坐标值。
    1079. 	*		显示中文且使用LINE宏时，需要把英文字体设置成Font8x16
    1080.  * @param  pStr ：要显示的英文字符串的首地址
    1081.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    1082.  * @retval 无
    1083.  */
    1084. void ILI9341_DispStringLine_EN (  uint16_t line,  char * pStr )
    1085. {
    1086. 	uint16_t usX = 0;
    1087. 	
    1088. 	while ( * pStr != '\0' )
    1089. 	{
    1090. 		if ( ( usX - ILI9341_DispWindow_X_Star + LCD_Currentfonts->Width ) > LCD_X_LENGTH )
    1091. 		{
    1092. 			usX = ILI9341_DispWindow_X_Star;
    1093. 			line += LCD_Currentfonts->Height;
    1094. 		}
    1095. 		
    1096. 		if ( ( line - ILI9341_DispWindow_Y_Star + LCD_Currentfonts->Height ) > LCD_Y_LENGTH )
    1097. 		{
    1098. 			usX = ILI9341_DispWindow_X_Star;
    1099. 			line = ILI9341_DispWindow_Y_Star;
    1100. 		}
    1101. 		
    1102. 		ILI9341_DispChar_EN ( usX, line, * pStr);
    1103. 		
    1104. 		pStr ++;
    1105. 		
    1106. 		usX += LCD_Currentfonts->Width;
    1107. 		
    1108. 	}
    1109. 	
    1110. }
    1111.  
    1112.  
    1113. /**
    1114.  * @brief  在 ILI9341 显示器上显示英文字符串
    1115.  * @param  usX ：在特定扫描方向下字符的起始X坐标
    1116.  * @param  usY ：在特定扫描方向下字符的起始Y坐标
    1117.  * @param  pStr ：要显示的英文字符串的首地址
    1118.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    1119.  * @retval 无
    1120.  */
    1121. void ILI9341_DispString_EN ( 	uint16_t usX ,uint16_t usY,  char * pStr )
    1122. {
    1123. 	while ( * pStr != '\0' )
    1124. 	{
    1125. 		if ( ( usX - ILI9341_DispWindow_X_Star + LCD_Currentfonts->Width ) > LCD_X_LENGTH )
    1126. 		{
    1127. 			usX = ILI9341_DispWindow_X_Star;
    1128. 			usY += LCD_Currentfonts->Height;
    1129. 		}
    1130. 		
    1131. 		if ( ( usY - ILI9341_DispWindow_Y_Star + LCD_Currentfonts->Height ) > LCD_Y_LENGTH )
    1132. 		{
    1133. 			usX = ILI9341_DispWindow_X_Star;
    1134. 			usY = ILI9341_DispWindow_Y_Star;
    1135. 		}
    1136. 		
    1137. 		ILI9341_DispChar_EN ( usX, usY, * pStr);
    1138. 		
    1139. 		pStr ++;
    1140. 		
    1141. 		usX += LCD_Currentfonts->Width;
    1142. 		
    1143. 	}
    1144. 	
    1145. }
    1146.  
    1147.  
    1148. /**
    1149.  * @brief  在 ILI9341 显示器上显示英文字符串(沿Y轴方向)
    1150.  * @param  usX ：在特定扫描方向下字符的起始X坐标
    1151.  * @param  usY ：在特定扫描方向下字符的起始Y坐标
    1152.  * @param  pStr ：要显示的英文字符串的首地址
    1153.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    1154.  * @retval 无
    1155.  */
    1156. void ILI9341_DispString_EN_YDir (	 uint16_t usX,uint16_t usY ,  char * pStr )
    1157. {	
    1158. 	while ( * pStr != '\0' )
    1159. 	{
    1160. 		if ( ( usY - ILI9341_DispWindow_Y_Star + LCD_Currentfonts->Height ) >LCD_Y_LENGTH  )
    1161. 		{
    1162. 			usY = ILI9341_DispWindow_Y_Star;
    1163. 			usX += LCD_Currentfonts->Width;
    1164. 		}
    1165. 		
    1166. 		if ( ( usX - ILI9341_DispWindow_X_Star + LCD_Currentfonts->Width ) >  LCD_X_LENGTH)
    1167. 		{
    1168. 			usX = ILI9341_DispWindow_X_Star;
    1169. 			usY = ILI9341_DispWindow_Y_Star;
    1170. 		}
    1171. 		
    1172. 		ILI9341_DispChar_EN ( usX, usY, * pStr);
    1173. 		
    1174. 		pStr ++;
    1175. 		
    1176. 		usY += LCD_Currentfonts->Height;		
    1177. 	}	
    1178. }
    1179.  
    1180.  
    1181. /**
    1182.  * @brief  在 ILI9341 显示器上显示中英文字符串
    1183.  * @param  usX ：在特定扫描方向下字符的起始X坐标
    1184.  * @param  usY ：在特定扫描方向下字符的起始Y坐标
    1185.  * @param  pStr ：要显示的字符串的首地址
    1186.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    1187.  * @retval 无
    1188.  */
    1189. void ILI9341_DispString_EN_CH ( 	uint16_t usX , uint16_t usY, char * pStr )
    1190. {
    1191. 	uint16_t usCh;
    1192. 	
    1193. 	while( * pStr != '\0' )
    1194. 	{
    1195. 		if ( * pStr <= 126 )	           	//英文字符
    1196. 		{
    1197. 			if ( ( usX - ILI9341_DispWindow_X_Star + LCD_Currentfonts->Width ) > LCD_X_LENGTH )
    1198. 			{
    1199. 				usX = ILI9341_DispWindow_X_Star;
    1200. 				usY += LCD_Currentfonts->Height;
    1201. 			}
    1202. 			
    1203. 			if ( ( usY - ILI9341_DispWindow_Y_Star + LCD_Currentfonts->Height ) > LCD_Y_LENGTH )
    1204. 			{
    1205. 				usX = ILI9341_DispWindow_X_Star;
    1206. 				usY = ILI9341_DispWindow_Y_Star;
    1207. 			}			
    1208. 		
    1209. 		  ILI9341_DispChar_EN ( usX, usY, * pStr );
    1210. 			
    1211. 			usX +=  LCD_Currentfonts->Width;
    1212. 		
    1213. 		  pStr ++;
    1214.  
    1215. 		}
    1216. 		
    1217. 		else	                            //汉字字符
    1218. 		{
    1219. 			if ( ( usX - ILI9341_DispWindow_X_Star + WIDTH_CH_CHAR ) > LCD_X_LENGTH )
    1220. 			{
    1221. 				usX = ILI9341_DispWindow_X_Star;
    1222. 				usY += HEIGHT_CH_CHAR;
    1223. 			}
    1224. 			
    1225. 			if ( ( usY - ILI9341_DispWindow_Y_Star + HEIGHT_CH_CHAR ) > LCD_Y_LENGTH )
    1226. 			{
    1227. 				usX = ILI9341_DispWindow_X_Star;
    1228. 				usY = ILI9341_DispWindow_Y_Star;
    1229. 			}	
    1230. 			
    1231. 			usCh = * ( uint16_t * ) pStr;	
    1232. 			
    1233. 			usCh = ( usCh << 8 ) + ( usCh >> 8 );		
    1234.  
    1235. 			ILI9341_DispChar_CH ( usX, usY, usCh );
    1236. 			
    1237. 			usX += WIDTH_CH_CHAR;
    1238. 			
    1239. 			pStr += 2;           //一个汉字两个字节 
    1240. 		
    1241.     }
    1242. 		
    1243.   }	
    1244. } 
    1245.  
    1246.  
    1247. /**
    1248.  * @brief  在 ILI9341 显示器上显示中英文字符串
    1249.  * @param  line ：在特定扫描方向下字符串的起始Y坐标
    1250.   *   本参数可使用宏LINE(0)、LINE(1)等方式指定文字坐标，
    1251.   *   宏LINE(x)会根据当前选择的字体来计算Y坐标值。
    1252. 	*		显示中文且使用LINE宏时，需要把英文字体设置成Font8x16
    1253.  * @param  pStr ：要显示的字符串的首地址
    1254.  * @note 可使用LCD_SetBackColor、LCD_SetTextColor、LCD_SetColors函数设置颜色
    1255.  * @retval 无
    1256.  */
    1257. void ILI9341_DispStringLine_EN_CH (  uint16_t line, char * pStr )
    1258. {
    1259. 	uint16_t usCh;
    1260. 	uint16_t usX = 0;
    1261. 	
    1262. 	while( * pStr != '\0' )
    1263. 	{
    1264. 		if ( * pStr <= 126 )	           	//英文字符
    1265. 		{
    1266. 			if ( ( usX - ILI9341_DispWindow_X_Star + LCD_Currentfonts->Width ) > LCD_X_LENGTH )
    1267. 			{
    1268. 				usX = ILI9341_DispWindow_X_Star;
    1269. 				line += LCD_Currentfonts->Height;
    1270. 			}
    1271. 			
    1272. 			if ( ( line - ILI9341_DispWindow_Y_Star + LCD_Currentfonts->Height ) > LCD_Y_LENGTH )
    1273. 			{
    1274. 				usX = ILI9341_DispWindow_X_Star;
    1275. 				line = ILI9341_DispWindow_Y_Star;
    1276. 			}			
    1277. 		
    1278. 		  ILI9341_DispChar_EN ( usX, line, * pStr );
    1279. 			
    1280. 			usX +=  LCD_Currentfonts->Width;
    1281. 		
    1282. 		  pStr ++;
    1283.  
    1284. 		}
    1285. 		
    1286. 		else	                            //汉字字符
    1287. 		{
    1288. 			if ( ( usX - ILI9341_DispWindow_X_Star + WIDTH_CH_CHAR ) > LCD_X_LENGTH )
    1289. 			{
    1290. 				usX = ILI9341_DispWindow_X_Star;
    1291. 				line += HEIGHT_CH_CHAR;
    1292. 			}
    1293. 			
    1294. 			if ( ( line - ILI9341_DispWindow_Y_Star + HEIGHT_CH_CHAR ) > LCD_Y_LENGTH )
    1295. 			{
    1296. 				usX = ILI9341_DispWindow_X_Star;
    1297. 				line = ILI9341_DispWindow_Y_Star;
    1298. 			}	
    1299. 			
    1300. 			usCh = * ( uint16_t * ) pStr;	
    1301. 			
    1302. 			usCh = ( usCh << 8 ) + ( usCh >> 8 );		
    1303.  
    1304. 			ILI9341_DispChar_CH ( usX, line, usCh );
    1305. 			
    1306. 			usX += WIDTH_CH_CHAR;
    1307. 			
    1308. 			pStr += 2;           //一个汉字两个字节 
    1309. 		
    1310.     }
    1311. 		
    1312.   }	
    1313. } 
    1314.  
    1315. /**
    1316.   * @brief  设置英文字体类型
    1317.   * @param  fonts: 指定要选择的字体
    1318. 	*		参数为以下值之一
    1319.   * 	@arg：Font24x32;
    1320.   * 	@arg：Font16x24;
    1321.   * 	@arg：Font8x16;
    1322.   * @retval None
    1323.   */
    1324. void LCD_SetFont(sFONT *fonts)
    1325. {
    1326.   LCD_Currentfonts = fonts;
    1327. }
    1328.  
    1329. /**
    1330.   * @brief  获取当前字体类型
    1331.   * @param  None.
    1332.   * @retval 返回当前字体类型
    1333.   */
    1334. sFONT *LCD_GetFont(void)
    1335. {
    1336.   return LCD_Currentfonts;
    1337. }
    1338.  
    1339.  
    1340. /**
    1341.   * @brief  设置LCD的前景(字体)及背景颜色,RGB565
    1342.   * @param  TextColor: 指定前景(字体)颜色
    1343.   * @param  BackColor: 指定背景颜色
    1344.   * @retval None
    1345.   */
    1346. void LCD_SetColors(uint16_t TextColor, uint16_t BackColor) 
    1347. {
    1348.   CurrentTextColor = TextColor; 
    1349.   CurrentBackColor = BackColor;
    1350. }
    1351.  
    1352. /**
    1353.   * @brief  获取LCD的前景(字体)及背景颜色,RGB565
    1354.   * @param  TextColor: 用来存储前景(字体)颜色的指针变量
    1355.   * @param  BackColor: 用来存储背景颜色的指针变量
    1356.   * @retval None
    1357.   */
    1358. void LCD_GetColors(uint16_t *TextColor, uint16_t *BackColor)
    1359. {
    1360.   *TextColor = CurrentTextColor;
    1361.   *BackColor = CurrentBackColor;
    1362. }
    1363.  
    1364. /**
    1365.   * @brief  设置LCD的前景(字体)颜色,RGB565
    1366.   * @param  Color: 指定前景(字体)颜色 
    1367.   * @retval None
    1368.   */
    1369. void LCD_SetTextColor(uint16_t Color)
    1370. {
    1371.   CurrentTextColor = Color;
    1372. }
    1373.  
    1374. /**
    1375.   * @brief  设置LCD的背景颜色,RGB565
    1376.   * @param  Color: 指定背景颜色 
    1377.   * @retval None
    1378.   */
    1379. void LCD_SetBackColor(uint16_t Color)
    1380. {
    1381.   CurrentBackColor = Color;
    1382. }
    1383.  
    1384.  
    1385. /**
    1386.   * @brief  清除某行文字
    1387.   * @param  Line: 指定要删除的行
    1388.   *   本参数可使用宏LINE(0)、LINE(1)等方式指定要删除的行，
    1389.   *   宏LINE(x)会根据当前选择的字体来计算Y坐标值，并删除当前字体高度的第x行。
    1390.   * @retval None
    1391.   */
    1392. void LCD_ClearLine(uint16_t Line)
    1393. {
    1394.   ILI9341_Clear(0,Line,LCD_X_LENGTH,((sFONT *)LCD_GetFont())->Height);	/* 清屏，显示全黑 */
    1395.  
    1396. }
    1397.  
    1398.  
    1399.  
    1400. /***********************缩放字体****************************/
    1401. #define ZOOMMAXBUFF 16384
    1402. uint8_t zoomBuff[ZOOMMAXBUFF] = {0};	//用于缩放的缓存，最大支持到128*128
    1403. uint8_t zoomTempBuff[1024] = {0};
    1404.  
    1405. /**
    1406.  * @brief  缩放字模，缩放后的字模由1个像素点由8个数据位来表示
    1407. 										0x01表示笔迹，0x00表示空白区
    1408.  * @param  in_width ：原始字符宽度
    1409.  * @param  in_heig ：原始字符高度
    1410.  * @param  out_width ：缩放后的字符宽度
    1411.  * @param  out_heig：缩放后的字符高度
    1412.  * @param  in_ptr ：字库输入指针	注意：1pixel 1bit
    1413.  * @param  out_ptr ：缩放后的字符输出指针 注意: 1pixel 8bit
    1414.  *		out_ptr实际上没有正常输出，改成了直接输出到全局指针zoomBuff中
    1415.  * @param  en_cn ：0为英文，1为中文
    1416.  * @retval 无
    1417.  */
    1418. void ILI9341_zoomChar(uint16_t in_width,	//原始字符宽度
    1419. 									uint16_t in_heig,		//原始字符高度
    1420. 									uint16_t out_width,	//缩放后的字符宽度
    1421. 									uint16_t out_heig,	//缩放后的字符高度
    1422. 									uint8_t *in_ptr,	//字库输入指针	注意：1pixel 1bit
    1423. 									uint8_t *out_ptr, //缩放后的字符输出指针 注意: 1pixel 8bit
    1424. 									uint8_t en_cn)		//0为英文，1为中文	
    1425. {
    1426. 	uint8_t *pts,*ots;
    1427. 	//根据源字模及目标字模大小，设定运算比例因子，左移16是为了把浮点运算转成定点运算
    1428. 	unsigned int xrIntFloat_16=(in_width<<16)/out_width+1; 
    1429.   unsigned int yrIntFloat_16=(in_heig<<16)/out_heig+1;
    1430. 	
    1431. 	unsigned int srcy_16=0;
    1432. 	unsigned int y,x;
    1433. 	uint8_t *pSrcLine;
    1434. 	
    1435. 	uint16_t byteCount,bitCount;
    1436. 	
    1437. 	//检查参数是否合法
    1438. 	if(in_width >= 32) return;												//字库不允许超过32像素
    1439. 	if(in_width * in_heig == 0) return;	
    1440. 	if(in_width * in_heig >= 1024 ) return; 					//限制输入最大 32*32
    1441. 	
    1442. 	if(out_width * out_heig == 0) return;	
    1443. 	if(out_width * out_heig >= ZOOMMAXBUFF ) return; //限制最大缩放 128*128
    1444. 	pts = (uint8_t*)&zoomTempBuff;
    1445. 	
    1446. 	//为方便运算，字库的数据由1 pixel/1bit 映射到1pixel/8bit
    1447. 	//0x01表示笔迹，0x00表示空白区
    1448. 	if(en_cn == 0x00)//英文
    1449. 	{
    1450. 		//英文和中文字库上下边界不对，可在此处调整。需要注意tempBuff防止溢出
    1451. 			for(byteCount=0;byteCount8;byteCount++)	
    1452. 			{
    1453. 				for(bitCount=0;bitCount<8;bitCount++)
    1454. 					{						
    1455. 						//把源字模数据由位映射到字节
    1456. 						//in_ptr里bitX为1，则pts里整个字节值为1
    1457. 						//in_ptr里bitX为0，则pts里整个字节值为0
    1458. 						*pts++ = (in_ptr[byteCount] & (0x80>>bitCount))?1:0; 
    1459. 					}
    1460. 			}				
    1461. 	}
    1462. 	else //中文
    1463. 	{			
    1464. 			for(byteCount=0;byteCount8;byteCount++)	
    1465. 			{
    1466. 				for(bitCount=0;bitCount<8;bitCount++)
    1467. 					{						
    1468. 						//把源字模数据由位映射到字节
    1469. 						//in_ptr里bitX为1，则pts里整个字节值为1
    1470. 						//in_ptr里bitX为0，则pts里整个字节值为0
    1471. 						*pts++ = (in_ptr[byteCount] & (0x80>>bitCount))?1:0; 
    1472. 					}
    1473. 			}		
    1474. 	}
    1475.  
    1476. 	//zoom过程
    1477. 	pts = (uint8_t*)&zoomTempBuff;	//映射后的源数据指针
    1478. 	ots = (uint8_t*)&zoomBuff;	//输出数据的指针
    1479. 	for (y=0;y/*行遍历*/
    1480.     {
    1481. 				unsigned int srcx_16=0;
    1482.         pSrcLine=pts+in_width*(srcy_16>>16);				
    1483.         for (x=0;x/*行内像素遍历*/
    1484.         {
    1485.             ots[x]=pSrcLine[srcx_16>>16]; //把源字模数据复制到目标指针中
    1486.             srcx_16+=xrIntFloat_16;			//按比例偏移源像素点
    1487.         }
    1488.         srcy_16+=yrIntFloat_16;				  //按比例偏移源像素点
    1489.         ots+=out_width;						
    1490.     }
    1491. 	/*！！！缩放后的字模数据直接存储到全局指针zoomBuff里了*/
    1492. 	out_ptr = (uint8_t*)&zoomBuff;	//out_ptr没有正确传出，后面调用直接改成了全局变量指针！
    1493. 	
    1494. 	/*实际中如果使用out_ptr不需要下面这一句！！！
    1495. 		只是因为out_ptr没有使用，会导致warning。强迫症*/
    1496. 	out_ptr++; 
    1497. }			
    1498.  
    1499.  
    1500. /**
    1501.  * @brief  利用缩放后的字模显示字符
    1502.  * @param  Xpos ：字符显示位置x
    1503.  * @param  Ypos ：字符显示位置y
    1504.  * @param  Font_width ：字符宽度
    1505.  * @param  Font_Heig：字符高度
    1506.  * @param  c ：要显示的字模数据
    1507.  * @param  DrawModel ：是否反色显示 
    1508.  * @retval 无
    1509.  */
    1510. void ILI9341_DrawChar_Ex(uint16_t usX, //字符显示位置x
    1511. 												uint16_t usY, //字符显示位置y
    1512. 												uint16_t Font_width, //字符宽度
    1513. 												uint16_t Font_Height,  //字符高度 
    1514. 												uint8_t *c,						//字模数据
    1515. 												uint16_t DrawModel)		//是否反色显示
    1516. {
    1517.   uint32_t index = 0, counter = 0;
    1518.  
    1519. 	//设置显示窗口
    1520. 	ILI9341_OpenWindow ( usX, usY, Font_width, Font_Height);
    1521. 	
    1522. 	ILI9341_Write_Cmd ( CMD_SetPixel );		
    1523. 	
    1524. 	//按字节读取字模数据
    1525. 	//由于前面直接设置了显示窗口，显示数据会自动换行
    1526. 	for ( index = 0; index < Font_Height; index++ )
    1527. 	{
    1528. 			//一位一位处理要显示的颜色
    1529. 			for ( counter = 0; counter < Font_width; counter++ )
    1530. 			{
    1531. 					//缩放后的字模数据，以一个字节表示一个像素位
    1532. 					//整个字节值为1表示该像素为笔迹
    1533. 					//整个字节值为0表示该像素为背景
    1534. 					if ( *c++ == DrawModel )
    1535. 						ILI9341_Write_Data ( CurrentBackColor );			
    1536. 					else
    1537. 						ILI9341_Write_Data ( CurrentTextColor );
    1538. 			}	
    1539. 	}	
    1540. }
    1541.  
    1542.  
    1543. /**
    1544.  * @brief  利用缩放后的字模显示字符串
    1545.  * @param  Xpos ：字符显示位置x
    1546.  * @param  Ypos ：字符显示位置y
    1547.  * @param  Font_width ：字符宽度，英文字符在此基础上/2。注意为偶数
    1548.  * @param  Font_Heig：字符高度，注意为偶数
    1549.  * @param  c ：要显示的字符串
    1550.  * @param  DrawModel ：是否反色显示 
    1551.  * @retval 无
    1552.  */
    1553. void ILI9341_DisplayStringEx(uint16_t x, 		//字符显示位置x
    1554. 														 uint16_t y, 				//字符显示位置y
    1555. 														 uint16_t Font_width,	//要显示的字体宽度，英文字符在此基础上/2。注意为偶数
    1556. 														 uint16_t Font_Height,	//要显示的字体高度，注意为偶数
    1557. 														 uint8_t *ptr,					//显示的字符内容
    1558. 														 uint16_t DrawModel)  //是否反色显示
    1559.  
    1560.  
    1561.  
    1562. {
    1563. 	uint16_t Charwidth = Font_width; //默认为Font_width，英文宽度为中文宽度的一半
    1564. 	uint8_t *psr;
    1565. 	uint8_t Ascii;	//英文
    1566. 	uint16_t usCh;  //中文
    1567. 	uint8_t ucBuffer [ WIDTH_CH_CHAR*HEIGHT_CH_CHAR/8 ];	
    1568. 	
    1569. 	while ( *ptr != '\0')
    1570. 	{
    1571. 			/****处理换行*****/
    1572. 			if ( ( x - ILI9341_DispWindow_X_Star + Charwidth ) > LCD_X_LENGTH )
    1573. 			{
    1574. 				x = ILI9341_DispWindow_X_Star;
    1575. 				y += Font_Height;
    1576. 			}
    1577. 			
    1578. 			if ( ( y - ILI9341_DispWindow_Y_Star + Font_Height ) > LCD_Y_LENGTH )
    1579. 			{
    1580. 				x = ILI9341_DispWindow_X_Star;
    1581. 				y = ILI9341_DispWindow_Y_Star;
    1582. 			}	
    1583. 			
    1584. 		if(*ptr > 0x80) //如果是中文
    1585. 		{			
    1586. 			Charwidth = Font_width;
    1587. 			usCh = * ( uint16_t * ) ptr;				
    1588. 			usCh = ( usCh << 8 ) + ( usCh >> 8 );
    1589. 			GetGBKCode ( ucBuffer, usCh );	//取字模数据
    1590. 			//缩放字模数据，源字模为16*16
    1591. 			ILI9341_zoomChar(WIDTH_CH_CHAR,HEIGHT_CH_CHAR,Charwidth,Font_Height,(uint8_t *)&ucBuffer,psr,1); 
    1592. 			//显示单个字符
    1593. 			ILI9341_DrawChar_Ex(x,y,Charwidth,Font_Height,(uint8_t*)&zoomBuff,DrawModel);
    1594. 			x+=Charwidth;
    1595. 			ptr+=2;
    1596. 		}
    1597. 		else
    1598. 		{
    1599. 				Charwidth = Font_width / 2;
    1600. 				Ascii = *ptr - 32;
    1601. 				//使用16*24字体缩放字模数据
    1602. 				ILI9341_zoomChar(16,24,Charwidth,Font_Height,(uint8_t *)&Font16x24.table[Ascii * Font16x24.Height*Font16x24.Width/8],psr,0);
    1603. 			  //显示单个字符
    1604. 				ILI9341_DrawChar_Ex(x,y,Charwidth,Font_Height,(uint8_t*)&zoomBuff,DrawModel);
    1605. 				x+=Charwidth;
    1606. 				ptr++;
    1607. 		}
    1608. 	}
    1609. }
    1610.  
    1611.  
    1612. /**
    1613.  * @brief  利用缩放后的字模显示字符串(沿Y轴方向)
    1614.  * @param  Xpos ：字符显示位置x
    1615.  * @param  Ypos ：字符显示位置y
    1616.  * @param  Font_width ：字符宽度，英文字符在此基础上/2。注意为偶数
    1617.  * @param  Font_Heig：字符高度，注意为偶数
    1618.  * @param  c ：要显示的字符串
    1619.  * @param  DrawModel ：是否反色显示 
    1620.  * @retval 无
    1621.  */
    1622. void ILI9341_DisplayStringEx_YDir(uint16_t x, 		//字符显示位置x
    1623. 																		 uint16_t y, 				//字符显示位置y
    1624. 																		 uint16_t Font_width,	//要显示的字体宽度，英文字符在此基础上/2。注意为偶数
    1625. 																		 uint16_t Font_Height,	//要显示的字体高度，注意为偶数
    1626. 																		 uint8_t *ptr,					//显示的字符内容
    1627. 																		 uint16_t DrawModel)  //是否反色显示
    1628. {
    1629. 	uint16_t Charwidth = Font_width; //默认为Font_width，英文宽度为中文宽度的一半
    1630. 	uint8_t *psr;
    1631. 	uint8_t Ascii;	//英文
    1632. 	uint16_t usCh;  //中文
    1633. 	uint8_t ucBuffer [ WIDTH_CH_CHAR*HEIGHT_CH_CHAR/8 ];	
    1634. 	
    1635. 	while ( *ptr != '\0')
    1636. 	{			
    1637. 			//统一使用汉字的宽高来计算换行
    1638. 			if ( ( y - ILI9341_DispWindow_X_Star + Font_width ) > LCD_Y_LENGTH )
    1639. 			{
    1640. 				y = ILI9341_DispWindow_X_Star;
    1641. 				x += Font_width;
    1642. 			}
    1643. 			
    1644. 			if ( ( x - ILI9341_DispWindow_Y_Star + Font_Height ) > LCD_X_LENGTH )
    1645. 			{
    1646. 				y = ILI9341_DispWindow_X_Star;
    1647. 				x = ILI9341_DispWindow_Y_Star;
    1648. 			}	
    1649. 			
    1650. 		if(*ptr > 0x80) //如果是中文
    1651. 		{			
    1652. 			Charwidth = Font_width;
    1653. 			usCh = * ( uint16_t * ) ptr;				
    1654. 			usCh = ( usCh << 8 ) + ( usCh >> 8 );
    1655. 			GetGBKCode ( ucBuffer, usCh );	//取字模数据
    1656. 			//缩放字模数据，源字模为16*16
    1657. 			ILI9341_zoomChar(WIDTH_CH_CHAR,HEIGHT_CH_CHAR,Charwidth,Font_Height,(uint8_t *)&ucBuffer,psr,1); 
    1658. 			//显示单个字符
    1659. 			ILI9341_DrawChar_Ex(x,y,Charwidth,Font_Height,(uint8_t*)&zoomBuff,DrawModel);
    1660. 			y+=Font_Height;
    1661. 			ptr+=2;
    1662. 		}
    1663. 		else
    1664. 		{
    1665. 				Charwidth = Font_width / 2;
    1666. 				Ascii = *ptr - 32;
    1667. 				//使用16*24字体缩放字模数据
    1668. 				ILI9341_zoomChar(16,24,Charwidth,Font_Height,(uint8_t *)&Font16x24.table[Ascii * Font16x24.Height*Font16x24.Width/8],psr,0);
    1669. 			  //显示单个字符
    1670. 				ILI9341_DrawChar_Ex(x,y,Charwidth,Font_Height,(uint8_t*)&zoomBuff,DrawModel);
    1671. 				y+=Font_Height;
    1672. 				ptr++;
    1673. 		}
    1674. 	}
    1675. }
    1676.  
    1677.  
    1678.  
    1679. /*********************end of file*************************/
    1680.  
    1681.

    LD3320.c/usart.c

    1. #include "bsp_usart.h"
    2. #include 
    3.  
    4.  /**
    5.   * @brief  USART GPIO 配置,工作参数配置
    6.   * @param  无
    7.   * @retval 无
    8.   */
    9. void USART_Config(void)
    10. {
    11. 	GPIO_InitTypeDef GPIO_InitStructure;
    12. 	USART_InitTypeDef USART_InitStructure;
    13.  
    14. 	// 打开串口GPIO的时钟
    15. 	DEBUG_USART_GPIO_APBxClkCmd(DEBUG_USART_GPIO_CLK, ENABLE);
    16. 	
    17. 	// 打开串口外设的时钟
    18. 	DEBUG_USART_APBxClkCmd(DEBUG_USART_CLK, ENABLE);
    19.  
    20. 	// 将USART Tx的GPIO配置为推挽复用模式
    21. 	GPIO_InitStructure.GPIO_Pin = DEBUG_USART_TX_GPIO_PIN;
    22. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    23. 	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    24. 	GPIO_Init(DEBUG_USART_TX_GPIO_PORT, &GPIO_InitStructure);
    25.  
    26.   // 将USART Rx的GPIO配置为浮空输入模式
    27. 	GPIO_InitStructure.GPIO_Pin = DEBUG_USART_RX_GPIO_PIN;
    28. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    29. 	GPIO_Init(DEBUG_USART_RX_GPIO_PORT, &GPIO_InitStructure);
    30. 	
    31. 	// 配置串口的工作参数
    32. 	// 配置波特率
    33. 	USART_InitStructure.USART_BaudRate = DEBUG_USART_BAUDRATE;
    34. 	// 配置 针数据字长
    35. 	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    36. 	// 配置停止位
    37. 	USART_InitStructure.USART_StopBits = USART_StopBits_1;
    38. 	// 配置校验位
    39. 	USART_InitStructure.USART_Parity = USART_Parity_No ;
    40. 	// 配置硬件流控制
    41. 	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    42. 	// 配置工作模式，收发一起
    43. 	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    44. 	// 完成串口的初始化配置
    45. 	USART_Init(DEBUG_USARTx, &USART_InitStructure);
    46.  
    47. 	// 使能串口
    48. 	USART_Cmd(DEBUG_USARTx, ENABLE);	    
    49. }
    50.  
    51.  
    52.  
    53. /**
    54.   * @brief  配置嵌套向量中断控制器NVIC
    55.   * @param  无
    56.   * @retval 无
    57.   */
    58. static void NVIC_USART3_Configuration(void)
    59. {
    60.   NVIC_InitTypeDef NVIC_InitStructure;//使能中断接收
    61.   
    62.   /* 嵌套向量中断控制器组选择 */
    63.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    64.   
    65.   /* 配置USART为中断源 */
    66.   NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
    67.   /* 抢断优先级*/
    68.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
    69.   /* 子优先级 */
    70.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
    71.   /* 使能中断 */
    72.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    73.   /* 初始化配置NVIC */
    74.   NVIC_Init(&NVIC_InitStructure);
    75.   
    76. }
    77.  
    78.  
    79.  
    80. /*
    81. PB10   ：TXD
    82. PB11   : RXD
    83. */
    84.  
    85. //串口IO初始化函数
    86. void USART3_Init(uint32_t baudrate)
    87. {
    88. 	GPIO_InitTypeDef GPIO_InitStructure;         //IO端口的初始化
    89. 	USART_InitTypeDef USART_InitStructure;			 //串口的初始化       
    90. 	
    91. 	RCC_APB2PeriphClockCmd(Ld3320_USART_GPIO_CLK, ENABLE);  //使能IO端口的时钟
    92.    RCC_APB1PeriphClockCmd(Ld3320_USART_CLK, ENABLE); //使能串口的时钟
    93. 	
    94. 	//发送
    95. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    96. 	GPIO_InitStructure.GPIO_Pin  = Ld3320_USART_TX_GPIO_PIN;  //发送引脚
    97. 	GPIO_InitStructure.GPIO_Speed= GPIO_Speed_50MHz;
    98. 	GPIO_Init(GPIOB, &GPIO_InitStructure);
    99. 	
    100. 	//接收
    101. 	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    102. 	GPIO_InitStructure.GPIO_Pin  = Ld3320_USART_RX_GPIO_PIN;  //接收引脚
    103. 	GPIO_InitStructure.GPIO_Speed= GPIO_Speed_50MHz;
    104. 	GPIO_Init(GPIOB,&GPIO_InitStructure);
    105.  
    106. 	USART_InitStructure.USART_BaudRate = baudrate;    //设置传输的波特率
    107. 	USART_InitStructure.USART_WordLength = USART_WordLength_8b;  //设置传输一帧数据的数据位
    108. 	USART_InitStructure.USART_StopBits = USART_StopBits_1;       //一位停止位
    109. 	USART_InitStructure.USART_Parity = USART_Parity_No;					 //无奇偶校验位
    110. 	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;  //能使接收的发送
    111. 	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;  //无硬件流控制
    112. 	USART_Init(Ld3320_USARTx,&USART_InitStructure);
    113. 	
    114. 	NVIC_USART3_Configuration();
    115. 	
    116. 	USART_ITConfig(Ld3320_USARTx,USART_IT_RXNE,ENABLE); //使能串口中断
    117.    USART_Cmd(Ld3320_USARTx,ENABLE);               //使能串口2
    118. 	
    119. }
    120.  
    121. /*
    122. 函数名：USART3串口发送函数
    123. 功能：  发送数据
    124. 入口参数：发送的字符
    125. */
    126. void USART3_SendString(u8 *str)
    127. {
    128. 		u8 index=0;
    129. 	  do
    130. 		{
    131. 					USART_SendData(USART3,str[index]);  //逐一的发送数组中的内容
    132. 					while(USART_GetFlagStatus(USART3,USART_FLAG_TXE) == RESET);  //判断是否发送完 发完为高电平
    133. 					index++;
    134. 		}
    135.     while(str[index] != 0);   //检查字符串结束标志
    136. }
    137.  
    138.  
    139. xUSATR_TypeDef  xUSART;         // 声明为全局变量,方便记录信息、状态
    140.  
    141.  
    142.  
    143.  
    144. //   USART-1   //
    145. /
    146. /******************************************************************************
    147.  * 函  数： vUSART1_Init
    148.  * 功  能： 初始化USART1的GPIO、通信参数配置、中断优先级
    149.  *          (8位数据、无校验、1个停止位)
    150.  * 参  数： uint32_t baudrate  通信波特率
    151.  * 返回值： 无
    152.  ******************************************************************************/
    153. void USART1_Init(uint32_t baudrate)
    154. {
    155.     GPIO_InitTypeDef  GPIO_InitStructure;
    156.     NVIC_InitTypeDef  NVIC_InitStructure;
    157.     USART_InitTypeDef USART_InitStructure;
    158.  
    159.     // 时钟使能
    160.     RCC->APB2ENR |= RCC_APB2ENR_USART1EN;                           // 使能USART1时钟
    161.     RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;                             // 使能GPIOA时钟
    162.  
    163.     // GPIO_TX引脚配置
    164.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_9;
    165.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    166.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;                // TX引脚工作模式：复用推挽
    167.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    168.     // GPIO_RX引脚配置
    169.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_10;
    170.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IPU;                  // RX引脚工作模式：上拉输入; 如果使用浮空输入，引脚空置时可能产生误输入; 当电路上为一主多从电路时，可以使用复用开漏模式
    171.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    172.  
    173.     // 中断配置
    174.     NVIC_InitStructure .NVIC_IRQChannel = USART1_IRQn;
    175.     NVIC_InitStructure .NVIC_IRQChannelPreemptionPriority = 2 ;     // 抢占优先级
    176.     NVIC_InitStructure .NVIC_IRQChannelSubPriority = 2;             // 子优先级
    177.     NVIC_InitStructure .NVIC_IRQChannelCmd = ENABLE;                // IRQ通道使能
    178.     NVIC_Init(&NVIC_InitStructure);
    179.  
    180.     //USART 初始化设置
    181.     USART_DeInit(USART1);
    182.     USART_InitStructure.USART_BaudRate   = baudrate;                // 串口波特率
    183.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;     // 字长为8位数据格式
    184.     USART_InitStructure.USART_StopBits   = USART_StopBits_1;        // 一个停止位
    185.     USART_InitStructure.USART_Parity     = USART_Parity_No;         // 无奇偶校验位
    186.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    187.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; // 使能收、发模式
    188.     USART_Init(USART1, &USART_InitStructure);                       // 初始化串口
    189.  
    190.     USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
    191.     USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);                  // 使能接受中断
    192.     USART_ITConfig(USART1, USART_IT_IDLE, ENABLE);                  // 使能空闲中断
    193.  
    194.     USART_Cmd(USART1, ENABLE);                                      // 使能串口, 开始工作
    195.  
    196.     USART1->SR = ~(0x00F0);                                         // 清理中断
    197.  
    198.     xUSART.USART1InitFlag = 1;                                      // 标记初始化标志
    199.     xUSART.USART1ReceivedNum = 0;                                   // 接收字节数清零
    200.  
    201.     printf("\r\r\r=========== 魔女开发板 STM32F103 外设初始报告 ===========\r");
    202.     printf("USART1初始化配置      接收中断、空闲中断, 发送中断\r");
    203. }
    204.  
    205. /******************************************************************************
    206.  * 函  数： USART1_IRQHandler
    207.  * 功  能： USART1的接收中断、空闲中断、发送中断
    208.  * 参  数： 无
    209.  * 返回值： 无
    210.  *
    211. ******************************************************************************/
    212. static uint8_t U1TxBuffer[256] ;    // 用于中断发送：环形缓冲区，256个字节
    213. static uint8_t U1TxCounter = 0 ;    // 用于中断发送：标记已发送的字节数(环形)
    214. static uint8_t U1TxCount   = 0 ;    // 用于中断发送：标记将要发送的字节数(环形)
    215.  
    216. void USART1_IRQHandler(void)
    217. {
    218.     static uint16_t cnt = 0;                                         // 接收字节数累计：每一帧数据已接收到的字节数
    219.     static uint8_t  RxTemp[U1_RX_BUF_SIZE];                          // 接收数据缓存数组：每新接收１个字节，先顺序存放到这里，当一帧接收完(发生空闲中断), 再转存到全局变量：xUSART.USARTxReceivedBuffer[xx]中；
    220.  
    221.     // 接收中断
    222.     if (USART1->SR & (1 << 5))                                       // 检查RXNE(读数据寄存器非空标志位); RXNE中断清理方法：读DR时自动清理；
    223.     {
    224.         if ((cnt >= U1_RX_BUF_SIZE))//||(xUSART.USART1ReceivedFlag==1// 判断1: 当前帧已接收到的数据量，已满(缓存区), 为避免溢出，本包后面接收到的数据直接舍弃．
    225.         {
    226.             // 判断2: 如果之前接收好的数据包还没处理，就放弃新数据，即，新数据帧不能覆盖旧数据帧，直至旧数据帧被处理．缺点：数据传输过快于处理速度时会掉包；好处：机制清晰，易于调试
    227.             USART1->DR;                                              // 读取数据寄存器的数据，但不保存．主要作用：读DR时自动清理接收中断标志；
    228.             return;
    229.         }
    230.         RxTemp[cnt++] = USART1->DR ;                                 // 把新收到的字节数据，顺序存放到RXTemp数组中；注意：读取DR时自动清零中断位；
    231.     }
    232.  
    233.     // 空闲中断, 用于配合接收中断，以判断一帧数据的接收完成
    234.     if (USART1->SR & (1 << 4))                                       // 检查IDLE(空闲中断标志位); IDLE中断标志清理方法：序列清零，USART1 ->SR;  USART1 ->DR;
    235.     {
    236.         xUSART.USART1ReceivedNum  = 0;                               // 把接收到的数据字节数清0
    237.         memcpy(xUSART.USART1ReceivedBuffer, RxTemp, U1_RX_BUF_SIZE); // 把本帧接收到的数据，存放到全局变量xUSART.USARTxReceivedBuffer中, 等待处理; 注意：复制的是整个数组，包括0值，以方便字符串数据
    238.         xUSART.USART1ReceivedNum  = cnt;                             // 把接收到的字节数，存放到全局变量xUSART.USARTxReceivedCNT中；
    239.         cnt = 0;                                                     // 接收字节数累计器，清零; 准备下一次的接收
    240.         memset(RxTemp, 0, U1_RX_BUF_SIZE);                           // 接收数据缓存数组，清零; 准备下一次的接收
    241.         USART1 ->SR;
    242.         USART1 ->DR;                                 // 清零IDLE中断标志位!! 序列清零，顺序不能错!!
    243.     }
    244.  
    245.     // 发送中断
    246.     if ((USART1->SR & 1 << 7) && (USART1->CR1 & 1 << 7))             // 检查TXE(发送数据寄存器空)、TXEIE(发送缓冲区空中断使能)
    247.     {
    248.         USART1->DR = U1TxBuffer[U1TxCounter++];                      // 读取数据寄存器值；注意：读取DR时自动清零中断位；
    249.         if (U1TxCounter == U1TxCount)
    250.             USART1->CR1 &= ~(1 << 7);                                // 已发送完成，关闭发送缓冲区空置中断 TXEIE
    251.     }
    252. }
    253.  
    254. /******************************************************************************
    255.  * 函  数： vUSART1_GetBuffer
    256.  * 功  能： 获取UART所接收到的数据
    257.  * 参  数： uint8_t* buffer   数据存放缓存地址
    258.  *          uint8_t* cnt      接收到的字节数
    259.  * 返回值： 0_没有接收到新数据， 非0_所接收到新数据的字节数
    260.  ******************************************************************************/
    261. uint8_t USART1_GetBuffer(uint8_t *buffer, uint8_t *cnt)
    262. {
    263.     if (xUSART.USART1ReceivedNum > 0)                                           // 判断是否有新数据
    264.     {
    265.         memcpy(buffer, xUSART.USART1ReceivedBuffer, xUSART.USART1ReceivedNum);  // 把新数据复制到指定位置
    266.         *cnt = xUSART.USART1ReceivedNum;                                        // 把新数据的字节数，存放指定变量
    267.         xUSART.USART1ReceivedNum = 0;                                           // 接收标记置0
    268.         return *cnt;                                                            // 返回所接收到新数据的字节数
    269.     }
    270.     return 0;                                                                   // 返回0, 表示没有接收到新数据
    271. }
    272.  
    273. /******************************************************************************
    274.  * 函  数： vUSART1_SendData
    275.  * 功  能： UART通过中断发送数据,适合各种数据类型
    276.  *         【适合场景】本函数可发送各种数据，而不限于字符串，如int,char
    277.  *         【不 适 合】注意环形缓冲区容量256字节，如果发送频率太高，注意波特率
    278.  * 参  数： uint8_t* buffer   需发送数据的首地址
    279.  *          uint8_t  cnt      发送的字节数 ，限于中断发送的缓存区大小，不能大于256个字节
    280.  * 返回值：
    281.  ******************************************************************************/
    282. void USART1_SendData(uint8_t *buf, uint8_t cnt)
    283. {
    284.     for (uint8_t i = 0; i < cnt; i++)
    285.         U1TxBuffer[U1TxCount++] = buf[i];
    286.  
    287.     if ((USART1->CR1 & 1 << 7) == 0)       // 检查发送缓冲区空置中断(TXEIE)是否已打开
    288.         USART1->CR1 |= 1 << 7;
    289. }
    290.  
    291. /******************************************************************************
    292.  * 函  数： vUSART1_SendString
    293.  * 功  能： UART通过中断发送输出字符串,无需输入数据长度
    294.  *         【适合场景】字符串，长度<=256字节
    295.  *         【不 适 合】int,float等数据类型
    296.  * 参  数： char* stringTemp   需发送数据的缓存首地址
    297.  * 返回值： 元
    298.  ******************************************************************************/
    299. void USART1_SendString(char *stringTemp)
    300. {
    301.     u16 num = 0;                                 // 字符串长度
    302.     char *t = stringTemp ;                       // 用于配合计算发送的数量
    303.     while (*t++ != 0)  num++;                    // 计算要发送的数目，这步比较耗时，测试发现每多6个字节，增加1us，单位：8位
    304.     USART1_SendData((u8 *)stringTemp, num);      // 注意调用函数所需要的真实数据长度; 如果目标需要以0作结尾判断，需num+1：字符串以0结尾，即多发一个:0
    305. }
    306.  
    307. /******************************************************************************
    308.  * 函  数： vUSART1_SendStringForDMA
    309.  * 功  能： UART通过DMA发送数据，省了占用中断的时间
    310.  *         【适合场景】字符串，字节数非常多，
    311.  *         【不 适 合】1:只适合发送字符串，不适合发送可能含0的数值类数据; 2-时间间隔要足够
    312.  * 参  数： char strintTemp  要发送的字符串首地址
    313.  * 返回值： 无
    314.  ******************************************************************************/
    315. void USART1_SendStringForDMA(char *stringTemp)
    316. {
    317.     static u8 Flag_DmaTxInit = 0;                // 用于标记是否已配置DMA发送
    318.     u32   num = 0;                               // 发送的数量，注意发送的单位不是必须8位的
    319.     char *t = stringTemp ;                       // 用于配合计算发送的数量
    320.  
    321.     while (*t++ != 0)  num++;                    // 计算要发送的数目，这步比较耗时，测试发现每多6个字节，增加1us，单位：8位
    322.  
    323.     while (DMA1_Channel4->CNDTR > 0);            // 重要：如果DMA还在进行上次发送，就等待; 得进完成中断清标志，F4不用这么麻烦，发送完后EN自动清零
    324.     if (Flag_DmaTxInit == 0)                     // 是否已进行过USAART_TX的DMA传输配置
    325.     {
    326.         Flag_DmaTxInit  = 1;                     // 设置标记，下次调用本函数就不再进行配置了
    327.         USART1 ->CR3   |= 1 << 7;                // 使能DMA发送
    328.         RCC->AHBENR    |= 1 << 0;                // 开启DMA1时钟  [0]DMA1   [1]DMA2
    329.  
    330.         DMA1_Channel4->CCR   = 0;                // 失能， 清0整个寄存器, DMA必须失能才能配置
    331.         DMA1_Channel4->CNDTR = num;              // 传输数据量
    332.         DMA1_Channel4->CMAR  = (u32)stringTemp;  // 存储器地址
    333.         DMA1_Channel4->CPAR  = (u32)&USART1->DR; // 外设地址
    334.  
    335.         DMA1_Channel4->CCR |= 1 << 4;            // 数据传输方向   0:从外设读   1:从存储器读
    336.         DMA1_Channel4->CCR |= 0 << 5;            // 循环模式       0:不循环     1：循环
    337.         DMA1_Channel4->CCR |= 0 << 6;            // 外设地址非增量模式
    338.         DMA1_Channel4->CCR |= 1 << 7;            // 存储器增量模式
    339.         DMA1_Channel4->CCR |= 0 << 8;            // 外设数据宽度为8位
    340.         DMA1_Channel4->CCR |= 0 << 10;           // 存储器数据宽度8位
    341.         DMA1_Channel4->CCR |= 0 << 12;           // 中等优先级
    342.         DMA1_Channel4->CCR |= 0 << 14;           // 非存储器到存储器模式
    343.     }
    344.     DMA1_Channel4->CCR  &= ~((u32)(1 << 0));     // 失能，DMA必须失能才能配置
    345.     DMA1_Channel4->CNDTR = num;                  // 传输数据量
    346.     DMA1_Channel4->CMAR  = (u32)stringTemp;      // 存储器地址
    347.     DMA1_Channel4->CCR  |= 1 << 0;               // 开启DMA传输
    348. }
    349.  
    350.  
    351.  
    352.  
    353.  
    354.  
    355. //   USART-2   //
    356. /
    357. /******************************************************************************
    358.  * 函  数： vUSART2_Init
    359.  * 功  能： 初始化USART的GPIO、通信参数配置、中断优先级
    360.  *          (8位数据、无校验、1个停止位)
    361.  * 参  数： uint32_t baudrate  通信波特率
    362.  * 返回值： 无
    363.  ******************************************************************************/
    364. void USART2_Init(uint32_t baudrate)
    365. {
    366.     GPIO_InitTypeDef  GPIO_InitStructure;
    367.     NVIC_InitTypeDef  NVIC_InitStructure;
    368.     USART_InitTypeDef USART_InitStructure;
    369.  
    370.     // 时钟使能
    371.     RCC->APB1ENR |= RCC_APB1ENR_USART2EN;                           // 使能USART2时钟
    372.     RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;                             // 使能GPIOA时钟
    373.  
    374.     // GPIO_TX引脚配置
    375.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_2;
    376.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    377.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;                // TX引脚工作模式：复用推挽
    378.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    379.     // GPIO_RX引脚配置
    380.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_3;
    381.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IPU;                  // RX引脚工作模式：上拉输入; 如果使用浮空输入，引脚空置时可能产生误输入; 当电路上为一主多从电路时，可以使用复用开漏模式
    382.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    383.  
    384.     // NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    385.     // 中断配置
    386.     NVIC_InitStructure .NVIC_IRQChannel = USART2_IRQn;
    387.     NVIC_InitStructure .NVIC_IRQChannelPreemptionPriority = 2 ;     // 抢占优先级
    388.     NVIC_InitStructure .NVIC_IRQChannelSubPriority = 2;             // 子优先级
    389.     NVIC_InitStructure .NVIC_IRQChannelCmd = ENABLE;                // IRQ通道使能
    390.     NVIC_Init(&NVIC_InitStructure);
    391.  
    392.     //USART 初始化设置
    393.     //USART_DeInit(USART2);
    394.     USART_InitStructure.USART_BaudRate   = baudrate;                // 串口波特率
    395.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;     // 字长为8位数据格式
    396.     USART_InitStructure.USART_StopBits   = USART_StopBits_1;        // 一个停止位
    397.     USART_InitStructure.USART_Parity     = USART_Parity_No;         // 无奇偶校验位
    398.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    399.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; // 使能收、发模式
    400.     USART_Init(USART2, &USART_InitStructure);                       // 初始化串口
    401.  
    402.     USART_ITConfig(USART2, USART_IT_TXE, DISABLE);
    403.     USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);                  // 使能接受中断
    404.     USART_ITConfig(USART2, USART_IT_IDLE, ENABLE);                  // 使能空闲中断
    405.  
    406.     USART_Cmd(USART2, ENABLE);                                      // 使能串口, 开始工作
    407.  
    408.     USART2->SR = ~(0x00F0);                                         // 清理中断
    409.  
    410.     xUSART.USART2InitFlag = 1;                                      // 标记初始化标志
    411.     xUSART.USART2ReceivedNum = 0;                                   // 接收字节数清零
    412.  
    413.     printf("\rUSART2初始化配置      接收中断、空闲中断, 发送中断\r");
    414. }
    415.  
    416. /******************************************************************************
    417.  * 函  数： USART2_IRQHandler
    418.  * 功  能： USART2的接收中断、空闲中断、发送中断
    419.  * 参  数： 无
    420.  * 返回值： 无
    421.  ******************************************************************************/
    422. static uint8_t U2TxBuffer[256] ;    // 用于中断发送：环形缓冲区，256个字节
    423. static uint8_t U2TxCounter = 0 ;    // 用于中断发送：标记已发送的字节数(环形)
    424. static uint8_t U2TxCount   = 0 ;    // 用于中断发送：标记将要发送的字节数(环形)
    425.  
    426. void USART2_IRQHandler(void)
    427. {
    428.     static uint16_t cnt = 0;                                         // 接收字节数累计：每一帧数据已接收到的字节数
    429.     static uint8_t  RxTemp[U2_RX_BUF_SIZE];                          // 接收数据缓存数组：每新接收１个字节，先顺序存放到这里，当一帧接收完(发生空闲中断), 再转存到全局变量：xUSART.USARTxReceivedBuffer[xx]中；
    430.  
    431.     // 接收中断
    432.     if (USART2->SR & (1 << 5))                                       // 检查RXNE(读数据寄存器非空标志位); RXNE中断清理方法：读DR时自动清理；
    433.     {
    434.         if ((cnt >= U2_RX_BUF_SIZE))//||xUSART.USART2ReceivedFlag==1 // 判断1: 当前帧已接收到的数据量，已满(缓存区), 为避免溢出，本包后面接收到的数据直接舍弃．
    435.         {
    436.             // 判断2: 如果之前接收好的数据包还没处理，就放弃新数据，即，新数据帧不能覆盖旧数据帧，直至旧数据帧被处理．缺点：数据传输过快于处理速度时会掉包；好处：机制清晰，易于调试
    437.             USART2->DR;                                              // 读取数据寄存器的数据，但不保存．主要作用：读DR时自动清理接收中断标志；
    438.             return;
    439.         }
    440.         RxTemp[cnt++] = USART2->DR ;                                 // 把新收到的字节数据，顺序存放到RXTemp数组中；注意：读取DR时自动清零中断位；
    441.     }
    442.  
    443.     // 空闲中断, 用于配合接收中断，以判断一帧数据的接收完成
    444.     if (USART2->SR & (1 << 4))                                       // 检查IDLE(空闲中断标志位); IDLE中断标志清理方法：序列清零，USART1 ->SR;  USART1 ->DR;
    445.     {
    446.         xUSART.USART2ReceivedNum  = 0;                               // 把接收到的数据字节数清0
    447.         memcpy(xUSART.USART2ReceivedBuffer, RxTemp, U2_RX_BUF_SIZE); // 把本帧接收到的数据，存放到全局变量xUSART.USARTxReceivedBuffer中, 等待处理; 注意：复制的是整个数组，包括0值，以方便字符串数据
    448.         xUSART.USART2ReceivedNum  = cnt;                             // 把接收到的字节数，存放到全局变量xUSART.USARTxReceivedCNT中；
    449.         cnt = 0;                                                     // 接收字节数累计器，清零; 准备下一次的接收
    450.         memset(RxTemp, 0, U2_RX_BUF_SIZE);                           // 接收数据缓存数组，清零; 准备下一次的接收
    451.         USART2 ->SR;
    452.         USART2 ->DR;                                 // 清零IDLE中断标志位!! 序列清零，顺序不能错!!
    453.     }
    454.  
    455.     // 发送中断
    456.     if ((USART2->SR & 1 << 7) && (USART2->CR1 & 1 << 7))             // 检查TXE(发送数据寄存器空)、TXEIE(发送缓冲区空中断使能)
    457.     {
    458.         USART2->DR = U2TxBuffer[U2TxCounter++];                      // 读取数据寄存器值；注意：读取DR时自动清零中断位；
    459.         if (U2TxCounter == U2TxCount)
    460.             USART2->CR1 &= ~(1 << 7);                                // 已发送完成，关闭发送缓冲区空置中断 TXEIE
    461.     }
    462. }
    463.  
    464. /******************************************************************************
    465.  * 函  数： vUSART2_GetBuffer
    466.  * 功  能： 获取UART所接收到的数据
    467.  * 参  数： uint8_t* buffer   数据存放缓存地址
    468.  *          uint8_t* cnt      接收到的字节数
    469.  * 返回值： 0_没有接收到新数据， 非0_所接收到新数据的字节数
    470.  ******************************************************************************/
    471. uint8_t USART2_GetBuffer(uint8_t *buffer, uint8_t *cnt)
    472. {
    473.     if (xUSART.USART2ReceivedNum > 0)                                          // 判断是否有新数据
    474.     {
    475.         memcpy(buffer, xUSART.USART2ReceivedBuffer, xUSART.USART2ReceivedNum); // 把新数据复制到指定位置
    476.         *cnt = xUSART.USART2ReceivedNum;                                       // 把新数据的字节数，存放指定变量
    477.         xUSART.USART2ReceivedNum = 0;                                          // 接收标记置0
    478.         return *cnt;                                                           // 返回所接收到新数据的字节数
    479.     }
    480.     return 0;                                                                  // 返回0, 表示没有接收到新数据
    481. }
    482.  
    483. /******************************************************************************
    484.  * 函  数： vUSART2_SendData
    485.  * 功  能： UART通过中断发送数据,适合各种数据类型
    486.  *         【适合场景】本函数可发送各种数据，而不限于字符串，如int,char
    487.  *         【不 适 合】注意环形缓冲区容量256字节，如果发送频率太高，注意波特率
    488.  * 参  数： uint8_t* buffer   需发送数据的首地址
    489.  *          uint8_t  cnt      发送的字节数 ，限于中断发送的缓存区大小，不能大于256个字节
    490.  * 返回值：
    491.  ******************************************************************************/
    492. void USART2_SendData(uint8_t *buf, uint8_t cnt)
    493. {
    494.     for (uint8_t i = 0; i < cnt; i++)
    495.         U2TxBuffer[U2TxCount++] = buf[i];
    496.  
    497.     if ((USART2->CR1 & 1 << 7) == 0)       // 检查发送缓冲区空置中断(TXEIE)是否已打开
    498.         USART2->CR1 |= 1 << 7;
    499. }
    500.  
    501. /******************************************************************************
    502.  * 函  数： vUSART2_SendString
    503.  * 功  能： UART通过中断发送输出字符串,无需输入数据长度
    504.  *         【适合场景】字符串，长度<=256字节
    505.  *         【不 适 合】int,float等数据类型
    506.  * 参  数： char* stringTemp   需发送数据的缓存首地址
    507.  * 返回值： 元
    508.  ******************************************************************************/
    509. void USART2_SendString(char *stringTemp)
    510. {
    511.     u16 num = 0;                                 // 字符串长度
    512.     char *t = stringTemp ;                       // 用于配合计算发送的数量
    513.     while (*t++ != 0)  num++;                    // 计算要发送的数目，这步比较耗时，测试发现每多6个字节，增加1us，单位：8位
    514.     USART2_SendData((u8 *)stringTemp, num);      // 注意调用函数所需要的真实数据长度; 如果目标需要以0作结尾判断，需num+1：字符串以0结尾，即多发一个:0
    515. }
    516.  
    517. /******************************************************************************
    518.  * 函  数： USART3_IRQHandler
    519.  * 功  能： USART的接收中断、空闲中断、发送中断
    520.  * 参  数： 无
    521.  * 返回值： 无
    522.  ******************************************************************************/
    523. static uint8_t U3TxBuffer[256] ;    // 用于中断发送：环形缓冲区，256个字节
    524. static uint8_t U3TxCounter = 0 ;    // 用于中断发送：标记已发送的字节数(环形)
    525. static uint8_t U3TxCount   = 0 ;    // 用于中断发送：标记将要发送的字节数(环形)
    526.  
    527. void USART3_SendData(uint8_t *buf, uint8_t cnt)
    528. {
    529.     for (uint8_t i = 0; i < cnt; i++)
    530.         U3TxBuffer[U3TxCount++] = buf[i];
    531.  
    532.     if ((USART3->CR1 & 1 << 7) == 0)       // 检查发送缓冲区空置中断(TXEIE)是否已打开
    533.         USART3->CR1 |= 1 << 7;
    534. }
    535.  
    536. /******************************************************************************
    537.  * 函  数： vUSART3_SendString
    538.  * 功  能： UART通过中断发送输出字符串,无需输入数据长度
    539.  *         【适合场景】字符串，长度<=256字节
    540.  *         【不 适 合】int,float等数据类型
    541.  * 参  数： char* stringTemp   需发送数据的缓存首地址
    542.  * 返回值： 元
    543.  ******************************************************************************/
    544. //void USART3_SendString(char *stringTemp)
    545. //{
    546. //    u16 num = 0;                                 // 字符串长度
    547. //    char *t = stringTemp ;                       // 用于配合计算发送的数量
    548. //    while (*t++ != 0)  num++;                    // 计算要发送的数目，这步比较耗时，测试发现每多6个字节，增加1us，单位：8位
    549. //    USART3_SendData((u8 *)stringTemp, num);      // 注意调用函数所需要的真实数据长度; 如果目标需要以0作结尾判断，需num+1：字符串以0结尾，即多发一个:0
    550. //}
    551.  
    552.  
    553. #ifdef STM32F10X_HD  // STM32F103R，及以上，才有UART4和UART5
    554.  
    555. //   UART-4   //
    556. /
    557. /******************************************************************************
    558.  * 函  数： vUART4_Init
    559.  * 功  能： 初始化USART的GPIO、通信参数配置、中断优先级
    560.  *          (8位数据、无校验、1个停止位)
    561.  * 参  数： uint32_t baudrate  通信波特率
    562.  * 返回值： 无
    563.  ******************************************************************************/
    564. void UART4_Init(uint32_t baudrate)
    565. {
    566.     GPIO_InitTypeDef  GPIO_InitStructure;
    567.     NVIC_InitTypeDef  NVIC_InitStructure;
    568.     USART_InitTypeDef USART_InitStructure;
    569.  
    570.     // 时钟使能
    571.     RCC->APB1ENR |= RCC_APB1ENR_UART4EN;                            // 使能UART4时钟
    572.     RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;                             // 使能GPIOC时钟
    573.  
    574.     // GPIO_TX引脚配置
    575.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_10;
    576.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    577.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;                // TX引脚工作模式：复用推挽    GPIO_Init(GPIOC, &GPIO_InitStructure);
    578.     GPIO_Init(GPIOC, &GPIO_InitStructure);
    579.     // GPIO_RX引脚配置
    580.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_11;
    581.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IPU;                  // RX引脚工作模式：上拉输入; 如果使用浮空输入，引脚空置时可能产生误输入; 当电路上为一主多从电路时，可以使用复用开漏模式
    582.     GPIO_Init(GPIOC, &GPIO_InitStructure);
    583.  
    584.     // NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    585.     // 中断配置
    586.     NVIC_InitStructure .NVIC_IRQChannel = UART4_IRQn;
    587.     NVIC_InitStructure .NVIC_IRQChannelPreemptionPriority = 2 ;     // 抢占优先级
    588.     NVIC_InitStructure .NVIC_IRQChannelSubPriority = 2;             // 子优先级
    589.     NVIC_InitStructure .NVIC_IRQChannelCmd = ENABLE;                // IRQ通道使能
    590.     NVIC_Init(&NVIC_InitStructure);
    591.  
    592.     //USART 初始化设置
    593.     USART_DeInit(UART4);
    594.     USART_InitStructure.USART_BaudRate   = baudrate;                // 串口波特率
    595.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;     // 字长为8位数据格式
    596.     USART_InitStructure.USART_StopBits   = USART_StopBits_1;        // 一个停止位
    597.     USART_InitStructure.USART_Parity     = USART_Parity_No;         // 无奇偶校验位
    598.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    599.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; // 使能收、发模式
    600.     USART_Init(UART4, &USART_InitStructure);                        // 初始化串口
    601.  
    602.     USART_ITConfig(UART4, USART_IT_TXE, DISABLE);
    603.     USART_ITConfig(UART4, USART_IT_RXNE, ENABLE);                   // 使能接受中断
    604.     USART_ITConfig(UART4, USART_IT_IDLE, ENABLE);                   // 使能空闲中断
    605.     
    606.     USART_Cmd(UART4, ENABLE);                                       // 使能串口, 开始工作
    607.  
    608.     UART4->SR = ~(0x00F0);                                          // 清理中断
    609.  
    610.     xUSART.UART4InitFlag = 1;                                       // 标记初始化标志
    611.     xUSART.UART4ReceivedNum = 0;                                    // 接收字节数清零
    612.  
    613.     printf("\rUART4 初始化配置      接收中断、空闲中断, 发送中断\r");
    614. }
    615.  
    616. /******************************************************************************
    617.  * 函  数： UART4_IRQHandler
    618.  * 功  能： USART2的接收中断、空闲中断、发送中断
    619.  * 参  数： 无
    620.  * 返回值： 无
    621.  ******************************************************************************/
    622. static uint8_t U4TxBuffer[256] ;    // 用于中断发送：环形缓冲区，256个字节
    623. static uint8_t U4TxCounter = 0 ;    // 用于中断发送：标记已发送的字节数(环形)
    624. static uint8_t U4TxCount   = 0 ;    // 用于中断发送：标记将要发送的字节数(环形)
    625.  
    626. void UART4_IRQHandler(void)
    627. {
    628.     static uint16_t cnt = 0;                                        // 接收字节数累计：每一帧数据已接收到的字节数
    629.     static uint8_t  RxTemp[U4_RX_BUF_SIZE];                         // 接收数据缓存数组：每新接收１个字节，先顺序存放到这里，当一帧接收完(发生空闲中断), 再转存到全局变量：xUSART.USARTxReceivedBuffer[xx]中；
    630.  
    631.     // 接收中断
    632.     if (UART4->SR & (1 << 5))                                       // 检查RXNE(读数据寄存器非空标志位); RXNE中断清理方法：读DR时自动清理；
    633.     {
    634.         if ((cnt >= U4_RX_BUF_SIZE))//||xUSART.UART4ReceivedFlag==1 // 判断1: 当前帧已接收到的数据量，已满(缓存区), 为避免溢出，本包后面接收到的数据直接舍弃．
    635.         {
    636.             // 判断2: 如果之前接收好的数据包还没处理，就放弃新数据，即，新数据帧不能覆盖旧数据帧，直至旧数据帧被处理．缺点：数据传输过快于处理速度时会掉包；好处：机制清晰，易于调试
    637.             UART4->DR;                                              // 读取数据寄存器的数据，但不保存．主要作用：读DR时自动清理接收中断标志；
    638.             return;
    639.         }
    640.         RxTemp[cnt++] = UART4->DR ;                                 // 把新收到的字节数据，顺序存放到RXTemp数组中；注意：读取DR时自动清零中断位；
    641.     }
    642.  
    643.     // 空闲中断, 用于配合接收中断，以判断一帧数据的接收完成
    644.     if (UART4->SR & (1 << 4))                                       // 检查IDLE(空闲中断标志位); IDLE中断标志清理方法：序列清零，USART1 ->SR;  USART1 ->DR;
    645.     {
    646.         xUSART.UART4ReceivedNum  = 0;                               // 把接收到的数据字节数清0
    647.         memcpy(xUSART.UART4ReceivedBuffer, RxTemp, U4_RX_BUF_SIZE); // 把本帧接收到的数据，存放到全局变量xUSART.USARTxReceivedBuffer中, 等待处理; 注意：复制的是整个数组，包括0值，以方便字符串数据
    648.         xUSART.UART4ReceivedNum  = cnt;                             // 把接收到的字节数，存放到全局变量xUSART.USARTxReceivedCNT中；
    649.         cnt = 0;                                                    // 接收字节数累计器，清零; 准备下一次的接收
    650.         memset(RxTemp, 0, U4_RX_BUF_SIZE);                          // 接收数据缓存数组，清零; 准备下一次的接收
    651.         UART4 ->SR;
    652.         UART4 ->DR;                                  // 清零IDLE中断标志位!! 序列清零，顺序不能错!!
    653.     }
    654.  
    655.     // 发送中断
    656.     if ((UART4->SR & 1 << 7) && (UART4->CR1 & 1 << 7))              // 检查TXE(发送数据寄存器空)、TXEIE(发送缓冲区空中断使能)
    657.     {
    658.         UART4->DR = U4TxBuffer[U4TxCounter++];                      // 读取数据寄存器值；注意：读取DR时自动清零中断位；
    659.         if (U4TxCounter == U4TxCount)
    660.             UART4->CR1 &= ~(1 << 7);                                // 已发送完成，关闭发送缓冲区空置中断 TXEIE
    661.     }
    662. }
    663.  
    664. /******************************************************************************
    665.  * 函  数： vUART4_GetBuffer
    666.  * 功  能： 获取UART所接收到的数据
    667.  * 参  数： uint8_t* buffer   数据存放缓存地址
    668.  *          uint8_t* cnt      接收到的字节数
    669.  * 返回值： 0_没有接收到新数据， 非0_所接收到新数据的字节数
    670.  ******************************************************************************/
    671. uint8_t UART4_GetBuffer(uint8_t *buffer, uint8_t *cnt)
    672. {
    673.     if (xUSART.UART4ReceivedNum > 0)                                         // 判断是否有新数据
    674.     {
    675.         memcpy(buffer, xUSART.UART4ReceivedBuffer, xUSART.UART4ReceivedNum); // 把新数据复制到指定位置
    676.         *cnt = xUSART.UART4ReceivedNum;                                      // 把新数据的字节数，存放指定变量
    677.         xUSART.UART4ReceivedNum = 0;                                         // 接收标记置0
    678.         return *cnt;                                                         // 返回所接收到新数据的字节数
    679.     }
    680.     return 0;                                                                // 返回0, 表示没有接收到新数据
    681. }
    682.  
    683. /******************************************************************************
    684.  * 函  数： vUART4_SendData
    685.  * 功  能： UART通过中断发送数据,适合各种数据类型
    686.  *         【适合场景】本函数可发送各种数据，而不限于字符串，如int,char
    687.  *         【不 适 合】注意环形缓冲区容量256字节，如果发送频率太高，注意波特率
    688.  * 参  数： uint8_t* buffer   需发送数据的首地址
    689.  *          uint8_t  cnt      发送的字节数 ，限于中断发送的缓存区大小，不能大于256个字节
    690.  * 返回值：
    691.  ******************************************************************************/
    692. void UART4_SendData(uint8_t *buf, uint8_t cnt)
    693. {
    694.     for (uint8_t i = 0; i < cnt; i++)
    695.         U4TxBuffer[U4TxCount++] = buf[i];
    696.  
    697.     if ((UART4->CR1 & 1 << 7) == 0)       // 检查发送缓冲区空置中断(TXEIE)是否已打开
    698.         UART4->CR1 |= 1 << 7;
    699. }
    700.  
    701. /******************************************************************************
    702.  * 函  数： vUART4_SendString
    703.  * 功  能： UART通过中断发送输出字符串,无需输入数据长度
    704.  *         【适合场景】字符串，长度<=256字节
    705.  *         【不 适 合】int,float等数据类型
    706.  * 参  数： char* stringTemp   需发送数据的缓存首地址
    707.  * 返回值： 元
    708.  ******************************************************************************/
    709. void UART4_SendString(char *stringTemp)
    710. {
    711.     u16 num = 0;                                 // 字符串长度
    712.     char *t = stringTemp ;                       // 用于配合计算发送的数量
    713.     while (*t++ != 0)  num++;                    // 计算要发送的数目，这步比较耗时，测试发现每多6个字节，增加1us，单位：8位
    714.     UART4_SendData((u8 *)stringTemp, num);       // 调用函数完成发送，num+1：字符串以0结尾，需多发一个:0
    715. }
    716.  
    717.  
    718.  
    719.  
    720. //   UART-4   //
    721. /
    722. /******************************************************************************
    723.  * 函  数： vUART5_Init
    724.  * 功  能： 初始化USART的GPIO、通信参数配置、中断优先级
    725.  *          (8位数据、无校验、1个停止位)
    726.  * 参  数： uint32_t baudrate  通信波特率
    727.  * 返回值： 无
    728.  ******************************************************************************/
    729. void UART5_Init(uint32_t baudrate)
    730. {
    731.     GPIO_InitTypeDef  GPIO_InitStructure;
    732.     NVIC_InitTypeDef  NVIC_InitStructure;
    733.     USART_InitTypeDef USART_InitStructure;
    734.  
    735.     // 时钟使能
    736.     RCC->APB1ENR |= RCC_APB1ENR_UART5EN;                            // 使能UART5时钟
    737.     RCC->APB2ENR |= RCC_APB2ENR_IOPDEN | RCC_APB2ENR_IOPCEN;        // 使能GPIO时钟
    738.  
    739.     // GPIO_TX引脚配置
    740.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_12;
    741.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    742.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF_PP;                // TX引脚工作模式：复用推挽
    743.     GPIO_Init(GPIOC, &GPIO_InitStructure);
    744.     // GPIO_RX引脚配置
    745.     GPIO_InitStructure.GPIO_Pin   = GPIO_Pin_2;
    746.     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_IPU;                  // RX引脚工作模式：上拉输入; 如果使用浮空输入，引脚空置时可能产生误输入; 当电路上为一主多从电路时，可以使用复用开漏模式
    747.     GPIO_Init(GPIOD, &GPIO_InitStructure);
    748.  
    749.     // NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    750.     // 中断配置
    751.     NVIC_InitStructure .NVIC_IRQChannel = UART5_IRQn;
    752.     NVIC_InitStructure .NVIC_IRQChannelPreemptionPriority = 2 ;     // 抢占优先级
    753.     NVIC_InitStructure .NVIC_IRQChannelSubPriority = 2;             // 子优先级
    754.     NVIC_InitStructure .NVIC_IRQChannelCmd = ENABLE;                // IRQ通道使能
    755.     NVIC_Init(&NVIC_InitStructure);
    756.  
    757.     //USART 初始化设置
    758.     USART_DeInit(UART5);
    759.     USART_InitStructure.USART_BaudRate   = baudrate;                // 串口波特率
    760.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;     // 字长为8位数据格式
    761.     USART_InitStructure.USART_StopBits   = USART_StopBits_1;        // 一个停止位
    762.     USART_InitStructure.USART_Parity     = USART_Parity_No;         // 无奇偶校验位
    763.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx; // 使能收、发模式
    764.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    765.     USART_Init(UART5, &USART_InitStructure);                        // 初始化串口
    766.  
    767.     USART_ITConfig(UART5, USART_IT_TXE, DISABLE);
    768.     USART_ITConfig(UART5, USART_IT_RXNE, ENABLE);                   // 使能接受中断
    769.     USART_ITConfig(UART5, USART_IT_IDLE, ENABLE);                   // 使能空闲中断
    770.  
    771.     USART_Cmd(UART5, ENABLE);                                       // 使能串口, 开始工作
    772.  
    773.     UART5->SR = ~(0x00F0);                                          // 清理中断
    774.  
    775.     xUSART.UART5InitFlag = 1;                                       // 标记初始化标志
    776.     xUSART.UART5ReceivedNum = 0;                                    // 接收字节数清零
    777.  
    778.     printf("\rUART5 初始化配置      接收中断、空闲中断, 发送中断\r");
    779. }
    780.  
    781. /******************************************************************************
    782.  * 函  数： UART5_IRQHandler
    783.  * 功  能： USART2的接收中断、空闲中断、发送中断
    784.  * 参  数： 无
    785.  * 返回值： 无
    786.  ******************************************************************************/
    787. static uint8_t U5TxBuffer[256] ;    // 用于中断发送：环形缓冲区，256个字节
    788. static uint8_t U5TxCounter = 0 ;    // 用于中断发送：标记已发送的字节数(环形)
    789. static uint8_t U5TxCount   = 0 ;    // 用于中断发送：标记将要发送的字节数(环形)
    790.  
    791. void UART5_IRQHandler(void)
    792. {
    793.     static uint16_t cnt = 0;                                        // 接收字节数累计：每一帧数据已接收到的字节数
    794.     static uint8_t  RxTemp[U5_RX_BUF_SIZE];                         // 接收数据缓存数组：每新接收１个字节，先顺序存放到这里，当一帧接收完(发生空闲中断), 再转存到全局变量：xUSART.USARTxReceivedBuffer[xx]中；
    795.  
    796.     // 接收中断
    797.     if (UART5->SR & (1 << 5))                                       // 检查RXNE(读数据寄存器非空标志位); RXNE中断清理方法：读DR时自动清理；
    798.     {
    799.         if ((cnt >= U5_RX_BUF_SIZE))//||xUSART.UART5ReceivedFlag==1 // 判断1: 当前帧已接收到的数据量，已满(缓存区), 为避免溢出，本包后面接收到的数据直接舍弃．
    800.         {
    801.             // 判断2: 如果之前接收好的数据包还没处理，就放弃新数据，即，新数据帧不能覆盖旧数据帧，直至旧数据帧被处理．缺点：数据传输过快于处理速度时会掉包；好处：机制清晰，易于调试
    802.             UART5->DR;                                              // 读取数据寄存器的数据，但不保存．主要作用：读DR时自动清理接收中断标志；
    803.             return;
    804.         }
    805.         RxTemp[cnt++] = UART5->DR ;                                 // 把新收到的字节数据，顺序存放到RXTemp数组中；注意：读取DR时自动清零中断位；
    806.     }
    807.  
    808.     // 空闲中断, 用于配合接收中断，以判断一帧数据的接收完成
    809.     if (UART5->SR & (1 << 4))                                       // 检查IDLE(空闲中断标志位); IDLE中断标志清理方法：序列清零，USART1 ->SR;  USART1 ->DR;
    810.     {
    811.         xUSART.UART5ReceivedNum  = 0;                               // 把接收到的数据字节数清0
    812.         memcpy(xUSART.UART5ReceivedBuffer, RxTemp, U5_RX_BUF_SIZE); // 把本帧接收到的数据，存放到全局变量xUSART.USARTxReceivedBuffer中, 等待处理; 注意：复制的是整个数组，包括0值，以方便字符串数据
    813.         xUSART.UART5ReceivedNum  = cnt;                             // 把接收到的字节数，存放到全局变量xUSART.USARTxReceivedCNT中；
    814.         cnt = 0;                                                    // 接收字节数累计器，清零; 准备下一次的接收
    815.         memset(RxTemp, 0, U5_RX_BUF_SIZE);                          // 接收数据缓存数组，清零; 准备下一次的接收
    816.         UART5 ->SR;
    817.         UART5 ->DR;                                  // 清零IDLE中断标志位!! 序列清零，顺序不能错!!
    818.     }
    819.  
    820.     // 发送中断
    821.     if ((UART5->SR & 1 << 7) && (UART5->CR1 & 1 << 7))              // 检查TXE(发送数据寄存器空)、TXEIE(发送缓冲区空中断使能)
    822.     {
    823.         UART5->DR = U5TxBuffer[U5TxCounter++];                      // 读取数据寄存器值；注意：读取DR时自动清零中断位；
    824.         if (U5TxCounter == U5TxCount)
    825.             UART5->CR1 &= ~(1 << 7);                                // 已发送完成，关闭发送缓冲区空置中断 TXEIE
    826.     }
    827. }
    828.  
    829. /******************************************************************************
    830.  * 函  数： vUART5_GetBuffer
    831.  * 功  能： 获取UART所接收到的数据
    832.  * 参  数： uint8_t* buffer   数据存放缓存地址
    833.  *          uint8_t* cnt      接收到的字节数
    834.  * 返回值： 0_没有接收到新数据， 非0_所接收到新数据的字节数
    835.  ******************************************************************************/
    836. uint8_t UART5_GetBuffer(uint8_t *buffer, uint8_t *cnt)
    837. {
    838.     if (xUSART.UART5ReceivedNum > 0)                                         // 判断是否有新数据
    839.     {
    840.         memcpy(buffer, xUSART.UART5ReceivedBuffer, xUSART.UART5ReceivedNum); // 把新数据复制到指定位置
    841.         *cnt = xUSART.UART5ReceivedNum;                                      // 把新数据的字节数，存放指定变量
    842.         xUSART.UART5ReceivedNum = 0;                                         // 接收标记置0
    843.         return *cnt;                                                         // 返回所接收到新数据的字节数
    844.     }
    845.     return 0;                                                                // 返回0, 表示没有接收到新数据
    846. }
    847.  
    848. /******************************************************************************
    849.  * 函  数： vUART5_SendData
    850.  * 功  能： UART通过中断发送数据,适合各种数据类型
    851.  *         【适合场景】本函数可发送各种数据，而不限于字符串，如int,char
    852.  *         【不 适 合】注意环形缓冲区容量256字节，如果发送频率太高，注意波特率
    853.  * 参  数： uint8_t* buffer   需发送数据的首地址
    854.  *          uint8_t  cnt      发送的字节数 ，限于中断发送的缓存区大小，不能大于256个字节
    855.  * 返回值：
    856.  ******************************************************************************/
    857. void UART5_SendData(uint8_t *buf, uint8_t cnt)
    858. {
    859.     for (uint8_t i = 0; i < cnt; i++)
    860.         U5TxBuffer[U5TxCount++] = buf[i];
    861.  
    862.     if ((UART5->CR1 & 1 << 7) == 0)       // 检查发送缓冲区空置中断(TXEIE)是否已打开
    863.         UART5->CR1 |= 1 << 7;
    864. }
    865.  
    866. /******************************************************************************
    867.  * 函  数： vUART5_SendString
    868.  * 功  能： UART通过中断发送输出字符串,无需输入数据长度
    869.  *         【适合场景】字符串，长度<=256字节
    870.  *         【不 适 合】int,float等数据类型
    871.  * 参  数： char* stringTemp   需发送数据的缓存首地址
    872.  * 返回值： 元
    873.  ******************************************************************************/
    874. void UART5_SendString(char *stringTemp)
    875. {
    876.     u16 num = 0;                                 // 字符串长度
    877.     char *t = stringTemp ;                       // 用于配合计算发送的数量
    878.     while (*t++ != 0)  num++;                    // 计算要发送的数目，这步比较耗时，测试发现每多6个字节，增加1us，单位：8位
    879.     UART5_SendData((u8 *)stringTemp, num);       // 注意调用函数所需要的真实数据长度; 如果目标需要以0作结尾判断，需num+1：字符串以0结尾，即多发一个:0
    880. }
    881.  
    882. #endif
    883.  
    884.  
    885.  
    886.  
    887.  
    888. //  printf   //
    889. /******************************************************************************
    890.  * 功  能： printf函数支持代码
    891.  *         【特别注意】加入以下代码, 使用printf函数时, 不再需要选择use MicroLIB
    892.  * 参  数：
    893.  * 返回值：
    894.  * 备  注： 最后修改_2020年07月15日
    895.  ******************************************************************************/
    896. //加入以下代码,支持printf函数,而不需要选择use MicroLIB
    897. //#pragma import(__use_no_semihosting)
    898. //struct __FILE
    899. //{
    900. //    int handle;
    901. //};                     // 标准库需要的支持函数
    902. //FILE __stdout;         // FILE 在stdio.h文件
    903. void _sys_exit(int x)
    904. {
    905.     x = x;             // 定义_sys_exit()以避免使用半主机模式
    906. }
    907.  
    908.  
    909.  
    910. //重定向 c 库函数 printf 到串口，重定向后可使用 printf 函数
    911. int fputc(int ch, FILE *f)
    912. {  /* 发送一个字节数据到串口 */
    913. USART_SendData(DEBUG_USARTx, (uint8_t) ch);
    914.  /* 等待发送完毕 */
    915. while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_TXE) == RESET);
    916.  return (ch);
    917.  }
    918.  
    919.  ///重定向 c 库函数 scanf 到串口，重写向后可使用 scanf、getchar 等函数
    920.  int fgetc(FILE *f)
    921.  {
    922.  /* 等待串口输入数据 */
    923.  while (USART_GetFlagStatus(DEBUG_USARTx, USART_FLAG_RXNE) == RESET);
    924.  
    925.  return (int)USART_ReceiveData(DEBUG_USARTx);
    926.  }
    927.  
    928.  
    929.  
    930.  
    931. ///*
    932. //函数名：USART3中断服务函数
    933. //功能：  接收数据
    934. //注意：接收数据长度可调：RXCOUNT
    935. //*/
    936. //void USART3_IRQHandler(void)
    937. //{
    938. //	u8 temp;
    939. //	
    940. //  if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
    941. //  {
    942. //		USART_ClearITPendingBit(USART3,USART_IT_RXNE);
    943. //		temp = USART_ReceiveData(USART3);
    944. //		if(temp == '\n' || RXCOUNT == 20)   //判断是否接收到一个完整字符
    945. //		{
    946. //			RXCOUNT = 0;
    947. //			RXOVER =1;    //接收数据完成标志位置1
    948. //			USART_ITConfig(USART3,USART_IT_RXNE,DISABLE);//失能串口接收中断标志	
    949. //		}
    950. //		else
    951. //		{
    952. //			RXBUF[RXCOUNT] = temp;   //依次存放到数组中
    953. //			RXCOUNT++;		           //字符长度变化
    954. //		}
    955. //	}
    956. //}

    main.c

    1. /**
    2.   ******************************************************************************
    3.   * @file    main.c
    4.   * @author  fire
    5.   * @version V1.0
    6.   * @date    2013-xx-xx
    7.   * @brief   rtc 测试，显示时间格式为: xx:xx:xx
    8.   ******************************************************************************
    9.   * @attention
    10.   *
    11.   * 实验平台:野火 F103-指南者 STM32 开发板 
    12.   * 论坛    :http://www.firebbs.cn
    13.   * 淘宝    :https://fire-stm32.taobao.com
    14.   *
    15.   ******************************************************************************
    16.   */
    17. 	
    18. #include "stm32f10x.h"
    19. #include "./usart/bsp_usart.h"
    20. #include "./rtc/bsp_rtc.h"
    21. #include "./lcd/bsp_ili9341_lcd.h"
    22. #include "./key/bsp_key.h"  
    23. #include "./DTH11/DTH11.h"
    24. #include "./Led/bsp_led.h"
    25. #include "./syn6288/syn6288.h"
    26. //变量声明
    27. u8 RXBUF[20];       //串口存储数组
    28. u8 RXOVER=0;        //串口接收标志位
    29. u8 RXCOUNT=0;       //串口计数变量  
    30. u8 i;               //清空数组变量
    31.  
    32.  
    33.  
    34. //时间更新函数
    35. void 											Update_FrameShow										(void);
    36.  
    37. //表盘框架绘制
    38. void 											DrawFixed_Frame										(void);
    39. void 											DrawExcel												(void);
    40. void 											DrawCongratulate										(void);
    41. void 											DrawTimeFrame											(void);
    42. void 											DrawExternal_Environmentz							(void);
    43. void 											DrawWish													(void);
    44. //语音处理函数
    45. void 											USART_Deal												(void);
    46.  
    47. // N = 2^32/365/24/60/60 = 136 年
    48.  
    49. /*时间结构体，默认时间2024-03-02 03:20:10*/
    50. struct rtc_time systmtime=
    51. {
    52. 10,20,3,1,2,2024,4
    53. };
    54.  
    55. extern __IO uint32_t TimeDisplay ;
    56. //温度参数
    57.  
    58. /**
    59.   * @brief  主函数
    60.   * @param  无  
    61.   * @retval 无
    62.   */
    63. int main()
    64. {		
    65. 	
    66. //可使用该宏设置是否使用液晶显示
    67. #ifdef  USE_LCD_DISPLAY
    68. 	
    69. 		ILI9341_Init ();         //LCD 初始化
    70. 		LCD_SetFont(&Font8x16);
    71. 		LCD_SetColors(CurrentTextColor,CurrentBackColor);
    72.  
    73. 		ILI9341_Clear(0,0,LCD_X_LENGTH,LCD_Y_LENGTH);	/* 清屏，显示全黑 */
    74. 		
    75. 		DrawFixed_Frame();//绘制固定物
    76.  
    77.  
    78. #endif
    79. 		//串口部分
    80. 	   USART_Config();		
    81. 		LED_Configuration();//LED配置
    82. 		SYN6288_Init(USART2);                             // 初始化; USART2-PA2
    83. 		USART3_Init(9600);											//LD3320串口初始化
    84. 		
    85. 		Key_GPIO_Config();
    86.  
    87. 		/* 配置RTC秒中断优先级 */
    88. 	  RTC_NVIC_Config();
    89. 	  RTC_CheckAndConfig(&systmtime);
    90. 	  DHT11_Init();  //初始化温度传感器引脚
    91. 	  
    92. 	  SYN6288_Say("已开灯");//Syn6288测试
    93. 	  //Temperuture_Get();
    94. 	  while (1)
    95. 	  {
    96. 	    /* 每过1s 更新一次时间*/
    97. 	    if (TimeDisplay == 1)
    98. 	    {
    99. 				/* 当前时间 */
    100. 	      Time_Display( RTC_GetCounter(),&systmtime); 
    101. 			//Time_Display1( RTC_GetCounter(),Temperature_Get(),&systmtime); //当加入温度获取时，温度获取
    102.  
    103. 	      TimeDisplay = 0;
    104. 	    }
    105. 			
    106. 			//按下按键，通过串口修改时间
    107. 			if( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON  )
    108. 			{
    109. 				struct rtc_time set_time;
    110.  
    111. 				/*使用串口接收设置的时间，输入数字时注意末尾要加回车*/
    112. 				Time_Regulate_Get(&set_time);
    113. 				/*用接收到的时间设置RTC*/
    114. 				Time_Adjust(&set_time);
    115. 				
    116. 				//向备份寄存器写入标志
    117. 				BKP_WriteBackupRegister(RTC_BKP_DRX, RTC_BKP_DATA);
    118.  
    119. 			} 
    120. 		  USART_Deal();
    121. 	  }
    122. }
    123.  
    124. /**************************************表盘框架绘制*****************************************/
    125.  
    126. /*
    127. 函数功能: 绘制所有固定物
    128. */
    129. void DrawFixed_Frame(void)
    130. {
    131. DrawExcel();
    132. DrawCongratulate();
    133. DrawTimeFrame();
    134. DrawExternal_Environmentz();
    135. DrawWish();
    136. }
    137.  
    138. /*
    139. 函数功能: 绘制表格
    140. */
    141. void DrawExcel(void)
    142. {
    143. ILI9341_DrawRectangle ( 0, 0, 240, 320, 0);
    144. ILI9341_DrawLine(0,136,50,136);
    145. ILI9341_DrawLine(185,136,240,136);
    146. ILI9341_DrawLine(0,180,240,180);
    147. ILI9341_DrawLine(0,200,240,200);
    148. ILI9341_DrawLine(48,200,48,320);
    149. ILI9341_DrawLine(240-48,200,240-48,320);
    150. }
    151. /*
    152. 函数功能: 绘制时钟表盘框架
    153. */
    154. void DrawTimeFrame(void)
    155. {
    156. 	uint8_t i;
    157. 	ILI9341_DrawCircle(RoundCenter_X,RoundCenter_Y,RoundRadius,0);//画外圆
    158. 	ILI9341_DrawCircle(RoundCenter_X,RoundCenter_Y,RoundCenter,1); //画中心圆
    159. 	//画刻度
    160. 	for(i=0;i<60;i++)
    161. 	{
    162. 		if(i%5==0)
    163. 		{//绘制圆大间距
    164. 		ILI9341_DrawAngleLine(RoundCenter_X,RoundCenter_Y,6*i,RoundRadius-6,RoundRadius,RoundInterval_Color);
    165. 		}
    166. 		else
    167. 		{//绘制圆小间距
    168. 		ILI9341_DrawAngleLine(RoundCenter_X,RoundCenter_Y,6*i,RoundRadius-3,RoundRadius,RoundInterval_Color);
    169. 		}
    170. 		
    171. 	}
    172. 	//OLED_WriteGRAM();  //刷新数据到OLED屏幕
    173. }
    174. /*
    175. 函数功能: 绘制龙年大吉
    176. */
    177. void DrawCongratulate(void)
    178. {
    179. 		ILI9341_DisplayStringEx(10,10,32,32,(uint8_t *)"龙",0);
    180. 		ILI9341_DisplayStringEx(240-32-10,10,32,32,(uint8_t *)"年",0);
    181. 		ILI9341_DisplayStringEx(10,3*32,32,32,(uint8_t *)"大",0);
    182. 		ILI9341_DisplayStringEx(240-32-10,3*32,32,32,(uint8_t *)"吉",0);
    183. }
    184.  
    185. /*
    186. 函数功能: 绘制外部环境
    187. */
    188. void DrawExternal_Environmentz(void)
    189. {
    190. ILI9341_DisplayStringEx(20,144,16,16,(uint8_t *)"天气：多云",0);//也可后续添加天气检测设备配置
    191. ILI9341_DisplayStringEx(120,144,16,16,(uint8_t *)"温度：",0);//其他添加可仿照温度配置
    192. ILI9341_DisplayStringEx(20,160,16,16,(uint8_t *)"位置：贵阳",0);//也可后续添加定位设备配置
    193. ILI9341_DisplayStringEx(120,160,16,16,(uint8_t *)"湿度：",0);//也可后续添加空气检测设备配置
    194.  
    195. }
    196. /*
    197. 函数功能: 绘制祝愿
    198. */
    199. void DrawWish(void)
    200. {
    201. ILI9341_DisplayStringEx(12,210,24,24,(uint8_t *)"宜",0);
    202. ILI9341_DisplayStringEx(204,210,24,24,(uint8_t *)"忌",0);
    203.  
    204. ILI9341_DisplayStringEx_YDir(8,240,16,16,(uint8_t *)"搞钱",0);
    205. ILI9341_DisplayStringEx_YDir(28,240,16,16,(uint8_t *)"毕业设计",0);
    206. ILI9341_DisplayStringEx_YDir(200,240,16,16,(uint8_t *)"晚睡晚起",0);
    207. ILI9341_DisplayStringEx_YDir(220,240,16,16,(uint8_t *)"打游戏",0);
    208.  
    209. ILI9341_DisplayStringEx(52,210,24,24,(uint8_t *)"等待开发",0);
    210. }
    211.  
    212.  
    213.  
    214.  
    215. /**************************************表盘框架绘制结束*****************************************/
    216. /*
    217. 函数功能: 更新时间框架显示，在RTC中断里调用
    218. */
    219. void Update_FrameShow(void)
    220. {
    221. 	/*1. 绘制秒针、分针、时针*/
    222. 	 //画秒针
    223. 	ILI9341_DrawAngleLine2(RoundCenter_X,RoundCenter_Y,systmtime.tm_sec*6-6-90,RoundCenter,RoundSecondHand,0);//清除之前的秒针
    224. 	ILI9341_DrawAngleLine(RoundCenter_X,RoundCenter_Y,systmtime.tm_sec*6-90,RoundCenter,RoundSecondHand,RoundSecondHand_Color);
    225. 	//画分针
    226. 	ILI9341_DrawAngleLine2(RoundCenter_X,RoundCenter_Y,systmtime.tm_min*6-6-90,RoundCenter,RoundMiuiteHand,0);
    227. 	ILI9341_DrawAngleLine(RoundCenter_X,RoundCenter_Y,systmtime.tm_min*6-90,RoundCenter,RoundMiuiteHand,RoundMiuiteHand_Color);
    228. 	//画时针	
    229. 	ILI9341_DrawAngleLine2(RoundCenter_X,RoundCenter_Y,systmtime.tm_hour*30-30-90,RoundCenter,RoundHourHand,0);
    230. 	ILI9341_DrawAngleLine(RoundCenter_X,RoundCenter_Y,systmtime.tm_hour*30-90,RoundCenter,RoundHourHand,RoundHourHand_Color);
    231. 	
    232. }
    233.  
    234. /***********************************END OF FILE*********************************/
    235.  
    236. //串口处理函数
    237. void USART_Deal(void)
    238. {
    239. 		if(RXOVER)
    240. 		{
    241. 			RXOVER = 0;    //清除接收标志位
    242. 			switch(RXBUF[0]-48)
    243. 			{
    244. 				case   1:GPIO_ResetBits(GPIOB,GPIO_Pin_0);   //点亮小灯
    245. 							SYN6288_Say("已开灯");
    246.  
    247. 								 break;
    248. 				
    249. 				case   2:GPIO_SetBits(GPIOB,GPIO_Pin_0); //熄灭小灯
    250. 							SYN6288_Say("已关灯");
    251.  
    252. 								 break;	
    253. 				default: break;			
    254. 			}
    255. 			USART3_SendString(RXBUF);    //发送给pc机上面打印显示			
    256. 			for(i=0;i<20;i++)            //将已接收数据的数组清空：共20个字符长度
    257. 			{
    258. 				 RXBUF[i] = 0;          	 //重置数据缓存区
    259. 			}
    260. 			USART_ITConfig(USART3,USART_IT_RXNE,ENABLE);//始能串口接收 
    261. 		}
    262. }
    263.

    液晶显示指针式时钟核心代码在上文已经放出，本文核心代码如上，本人撰写代码也需要时间，如需要全部代码或者仅需语音部分代码请私信我，感谢大家理解。

  • 相关阅读:
    Linux命令系列之ls——原来最简单的ls这么复杂
    (免费分享)基于springboot,vue公司财务系统
    《洛谷深入浅出基础篇》——P3405 citis and state ——哈希表
    聊聊 Nacos
    网工内推 | 金融业，网络管理岗，CCIE优先，最高30k
    【python实战】朋友因股票亏了，很惨常愤恨不平，当天我就分析出原因：怎么做到的？(听说关注我的人会暴富)
    [计算机网络基础]物理层详解
    二手闲置物品交易数据快照
    Debezium系列之：基于wal2json_streaming插件实时处理postgresql数据库超大数据
    Python-ONNX 相关
  • 原文地址：https://blog.csdn.net/C_say_easy_to_me/article/details/136347860