devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

基于stm32F103的座面声控台灯_syn6288控制灯

作者：小丑西瓜9 | 2024-06-02 21:22:45

赞

踩

syn6288控制灯

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 <math.h>
  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<usLength;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<usLength;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;byteCount<in_heig*in_width/8;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;byteCount<in_heig*in_width/8;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<out_heig;y++)	/*行遍历*/
  1480.     {
  1481. 				unsigned int srcx_16=0;
  1482.         pSrcLine=pts+in_width*(srcy_16>>16);				
  1483.         for (x=0;x<out_width;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 <string.h>
  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.

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

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/664370
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号