你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

stm32c8t6利用语音识别与播报检测DHT11温湿度

[复制链接]
STMCU小助手 发布时间:2022-10-16 18:27
其他串口利用printf函数输出文字
首先,你要想用printf函数的话需要配置串口的相关参数,也就是初始化,学过stm32的都清楚串口初始化的大概配置过程,这里我就不细讲了,重点讲一下printf函数,这个printf函数在MDK5里面好像是找不到的,看了网上很多教程,发现是在fputc这个函数里面修改串口的输出,而这个fput函数一般在usart.c文件里面,如下所示:

  1. //重定义fputc函数
  2. int fputc(int ch, FILE *f)
  3. {/*这个可以发送文字*/
  4.         while((USART3->SR & 0X40) == 0); //循环发送,直到发送完毕,给串口3发送数据
  5.         USART3->DR = (u8) ch;
  6.         while((USART1->SR & 0X40) == 0); //循环发送,直到发送完毕,给串口1发送数据
  7.         USART1->DR = (u8) ch;
  8.         return ch;
  9. }
复制代码

这里我设置这个printf函数同时输出到串口1和串口3,这个printf函数可以直接输出文字。有时候需要向串口发送文字信息这个printf函数很好用,不像其他函数只能一个一个发送出去。

stm32中u8 u16的格式后字符
u8是指数值0-255,定义u8输出格式是%d,同时也可以输出%c,比如得到一个字符是1,则输出用%c得到的是1,输出用%d得到是49
u16是指数值0-65535

stm32语音识别与播报检测温湿度
下面附上图片:

2020121521075047.jpg


温湿度的相关程序在原子哥的程序源码里面有,当然,在下面我也会附上我的程序:
串口1是与PC端进行通信的,串口2是与LD3320语音模块上面的51单片机进行通信,串口3是与MR628连接的
main.c
  1. /*
  2. 接线定义:
  3. MR628语音合成模块  语音识别模块LD3320是集成在51单片机STC11L08XE    DHT11温湿度传感器
  4. 红线--5V               语音识别模块5V->stm32 5V                                         信号线->stm32的PB11
  5. 黄线--PB10                           语音识别模块GND->stm32 GND
  6. 黑线--GND                           语音识别模块TX->stm32 RX PA3
  7.                                            语音识别模块RX->stm32 TX PA2                                                */                                                
  8. #include "led.h"
  9. #include "sys.h"
  10. #include "delay.h"
  11. #include "stdio.h"
  12. #include "usart.h"
  13. #include "dht11.h"

  14. int main(void)
  15. {
  16.         u8 m=0;                           
  17.         u8 temperature;  //温度变量            
  18.         u8 humidity;         //湿度变量
  19.         short t=9999;        
  20.         u8 flag=0;                 //标记位
  21.         u16 len2;
  22.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2:2位抢占优先级,2位响应优先级
  23.         delay_init();
  24.         LED_Init();        
  25.         uart_init(115200);
  26.         My_USART2_Init(9600);
  27.         USART3_Init(9600);
  28.         while(DHT11_Init())        //DHT11初始化        
  29.         {delay_ms(200);}        
  30.         printf("初始化成功");
  31.         while(1)
  32.         {
  33.                 if(USART2_RX_STA&0x8000)
  34.                 {                                          
  35.                         len2=USART2_RX_STA&0x3fff;//得到此次接收到的数据长度
  36.                         for(t=0;t<len2;t++)
  37.                         {
  38.                                 if(USART2_RX_BUF[0]=='0')//接收到51单片机发过来的信号0
  39.                                 {
  40.                                         if(flag==0)
  41.                                         {
  42.                                                 printf("<I>18");//播放提示音1
  43.                                                 flag=1;
  44.                                         }
  45.                                         else
  46.                                         {
  47.                                                 printf("<I>19");//播放提示音2
  48.                                                 flag=0;
  49.                                         }
  50.                                 delay_ms(1000);
  51.                                 printf("<G>你好,我是小杰\r\n");
  52.                                 }
  53.                                 if(USART2_RX_BUF[0]=='1')//接收到51单片机发过来的信号1
  54.                                 {printf("<G>现在温度是%d十%d摄氏度\r\n",temperature/10,temperature%10);}
  55.                                 if(USART2_RX_BUF[0]=='2')//接收到51单片机发过来的信号2
  56.                                 {printf("<G>现在湿度是%d十%d\r\n",humidity/10,humidity%10);}
  57.                                 if(USART2_RX_BUF[0]=='3')//接收到51单片机发过来的信号3
  58.                                 {printf("<G>好的!");
  59.                                 delay_ms(1000);
  60.                                 printf("<M>1\r\n");}
  61.                                 if(USART2_RX_BUF[0]=='4')//接收到51单片机发过来的信号4
  62.                                 {printf("<G>好的!");
  63.                                 delay_ms(1000);
  64.                                 printf("<M>2\r\n");}
  65.                                 if(USART2_RX_BUF[0]=='5')//接收到51单片机发过来的信号5
  66.                                 {printf("<G>好的!");
  67.                                 delay_ms(1000);
  68.                                 printf("<M>0\r\n");}
  69.                         }
  70.                         USART2_RX_STA=0;
  71.                 }               
  72.                 if(m%100==0)                        //每1s读取一次
  73.                 {                                                                          
  74.                         DHT11_Read_Data(&temperature,&humidity);        //读取温湿度值        
  75.                 }
  76.                 delay_ms(10);
  77.                 m++;
  78.                 if(m==200)
  79.                 {
  80.                         m=0;
  81.                         LED0=!LED0;
  82.                 }        
  83.         }
  84. }
复制代码

usart.c

  1. #include "sys.h"
  2. #include "usart.h"
  3. #include "timer.h"

  4. #if 1
  5. #pragma import(__use_no_semihosting)
  6. //标准库需要的支持函数
  7. struct __FILE
  8. {
  9.         int handle;

  10. };

  11. FILE __stdout;
  12. //定义_sys_exit()以避免使用半主机模式
  13. void _sys_exit(int x)
  14. {
  15.         x = x;
  16. }
  17. //重定义fputc函数
  18. int fputc(int ch, FILE *f)
  19. {/*这个可以发送文字*/
  20.         while((USART3->SR & 0X40) == 0); //循环发送,直到发送完毕,给串口3发送数据
  21.         USART3->DR = (u8) ch;
  22.         while((USART1->SR & 0X40) == 0); //循环发送,直到发送完毕,给串口1发送数据
  23.         USART1->DR = (u8) ch;
  24.         return ch;
  25. }
  26. #endif

  27. void USART3_SendData(u8 data)
  28. {
  29.         while((USART3->SR & 0X40) == 0);
  30.         USART3->DR = data;
  31. }

  32. void USART3_SendString(u8 *DAT, u8 len)
  33. {
  34.         u8 i;
  35.         for(i = 0; i < len; i++)
  36.         {
  37.                 USART3_SendData(*DAT++);
  38.         }
  39. }



  40. #if EN_USART3_RX   //如果使能了接收,一般在.h文件里面定义这个变量为1,也就是一直都是使能的
  41. u8 USART3_RX_BUF[USART3_REC_LEN];     //接收缓冲,最大USART3_REC_LEN个字节.
  42. //接收状态
  43. //bit15,        接收完成标志
  44. //bit14,        接收到0x0d
  45. //bit13~0,        接收到的有效字节数目
  46. u16 USART3_RX_STA = 0;     //接收状态标记

  47. void USART3_Init(u32 bound)
  48. {
  49.         //GPIO端口设置
  50.         GPIO_InitTypeDef GPIO_InitStructure;
  51.         USART_InitTypeDef USART_InitStructure;
  52.         NVIC_InitTypeDef NVIC_InitStructure;

  53.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);        //使能USART3,GPIOB时钟
  54.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
  55.         //USART3_TX   GPIOB.10
  56.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  57.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  58.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
  59.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIO

  60.         //USART3_RX          GPIOB.11初始化
  61.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
  62.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
  63.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIO

  64.         //USART3 NVIC 配置
  65.         NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
  66.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 3 ; //抢占优先级3
  67.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;                //子优先级3
  68.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
  69.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器

  70.         //USART 初始化设置

  71.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
  72.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
  73.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
  74.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
  75.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
  76.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式

  77.         USART_Init(USART3, &USART_InitStructure); //初始化串口3
  78.         USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//开启串口接受中断
  79.         USART_Cmd(USART3, ENABLE);                    //使能串口3

  80.         TIM3_Int_Init(99, 7199);                //10ms中断
  81.         USART3_RX_STA = 0;                //清零
  82.         TIM_Cmd(TIM3, DISABLE);                        //关闭定时器3
  83. }

  84. void USART3_IRQHandler(void)                        //串口3中断服务程序
  85. {
  86.         u8 Res;
  87.         if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET)
  88.         {
  89.                 Res = USART_ReceiveData(USART3);        //读取接收到的数据
  90.                 if((USART3_RX_STA & 0x8000) == 0) //接收未完成
  91.                 {
  92.                         if(USART3_RX_STA < USART3_REC_LEN)        //还可以接收数据
  93.                         {
  94.                                 TIM_SetCounter(TIM3, 0); //计数器清空                                          //计数器清空
  95.                                 if(USART3_RX_STA == 0)                                 //使能定时器3的中断
  96.                                 {
  97.                                         TIM_Cmd(TIM3, ENABLE); //使能定时器3
  98.                                 }
  99.                                 USART3_RX_BUF[USART3_RX_STA++] = Res;        //记录接收到的值
  100.                         }
  101.                         else
  102.                         {
  103.                                 USART3_RX_STA |= 1 << 15;                                //强制标记接收完成
  104.                         }
  105.                 }
  106.         }
  107. }
  108. #endif
  109. #if EN_USART1_RX   //如果使能了接收,一般在.h文件里面定义这个变量为1,也就是一直都是使能的
  110. //串口1中断服务程序
  111. //注意,读取USARTx->SR能避免莫名其妙的错误           
  112. u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
  113. //接收状态
  114. //bit15,        接收完成标志
  115. //bit14,        接收到0x0d
  116. //bit13~0,        接收到的有效字节数目
  117. u16 USART_RX_STA=0;       //接收状态标记         

  118. void uart_init(u32 bound){
  119.   //GPIO端口设置
  120.   GPIO_InitTypeDef GPIO_InitStructure;
  121.         USART_InitTypeDef USART_InitStructure;
  122.         NVIC_InitTypeDef NVIC_InitStructure;
  123.          
  124.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);        //使能USART1,GPIOA时钟

  125.         //USART1_TX   GPIOA.9
  126.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
  127.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  128.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
  129.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9

  130.   //USART1_RX          GPIOA.10初始化
  131.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
  132.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
  133.   GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  

  134.   //Usart1 NVIC 配置
  135.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
  136.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
  137.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;                //子优先级3
  138.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        //IRQ通道使能
  139.         NVIC_Init(&NVIC_InitStructure);        //根据指定的参数初始化VIC寄存器

  140.    //USART 初始化设置

  141.         USART_InitStructure.USART_BaudRate = bound;//串口波特率
  142.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
  143.         USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
  144.         USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
  145.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
  146.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        //收发模式

  147.   USART_Init(USART1, &USART_InitStructure); //初始化串口1
  148.   USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
  149.   USART_Cmd(USART1, ENABLE);                    //使能串口1

  150. }

  151. void USART1_IRQHandler(void)                        //串口1中断服务程序
  152.         {
  153.         u8 Res;
  154. #if SYSTEM_SUPPORT_OS                 //如果SYSTEM_SUPPORT_OS为真,则需要支持OS.
  155.         OSIntEnter();   
  156. #endif
  157.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
  158.                 {
  159.                 Res =USART_ReceiveData(USART1);        //读取接收到的数据
  160.                
  161.                 if((USART_RX_STA&0x8000)==0)//接收未完成
  162.                         {
  163.                         if(USART_RX_STA&0x4000)//接收到了0x0d
  164.                                 {
  165.                                 if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
  166.                                 else USART_RX_STA|=0x8000;        //接收完成了
  167.                                 }
  168.                         else //还没收到0X0D
  169.                                 {        
  170.                                 if(Res==0x0d)USART_RX_STA|=0x4000;
  171.                                 else
  172.                                         {
  173.                                         USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
  174.                                         USART_RX_STA++;
  175.                                         if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收         
  176.                                         }                 
  177.                                 }
  178.                         }                    
  179.      }
  180. #if SYSTEM_SUPPORT_OS         //如果SYSTEM_SUPPORT_OS为真,则需要支持OS.
  181.         OSIntExit();                                                                                          
  182. #endif
  183. }
  184. #if EN_USART2_RX   //如果使能了接收,一般在.h文件里面定义这个变量为1,也就是一直都是使能的
  185. u8 USART2_RX_BUF[USART2_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.
  186. u16 USART2_RX_STA = 0;                                 //接收状态标记         
  187. void My_USART2_Init(u32 bound)
  188. {
  189.         GPIO_InitTypeDef GPIO_InitStrue;
  190.         USART_InitTypeDef USART_InitStrue;
  191.         NVIC_InitTypeDef NVIC_InitStrue;
  192.         
  193.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
  194.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2,ENABLE);
  195.         
  196.         GPIO_InitStrue.GPIO_Mode=GPIO_Mode_AF_PP;
  197.         GPIO_InitStrue.GPIO_Pin=GPIO_Pin_2;
  198.         GPIO_InitStrue.GPIO_Speed=GPIO_Speed_10MHz;
  199.         GPIO_Init(GPIOA,&GPIO_InitStrue);
  200.         
  201.         GPIO_InitStrue.GPIO_Mode=GPIO_Mode_IN_FLOATING;
  202.         GPIO_InitStrue.GPIO_Pin=GPIO_Pin_3;
  203.         GPIO_InitStrue.GPIO_Speed=GPIO_Speed_10MHz;
  204.         GPIO_Init(GPIOA,&GPIO_InitStrue);
  205.         
  206.         USART_InitStrue.USART_BaudRate=bound;
  207.         USART_InitStrue.USART_HardwareFlowControl=USART_HardwareFlowControl_None;
  208.         USART_InitStrue.USART_Mode=USART_Mode_Rx|USART_Mode_Tx;
  209.         USART_InitStrue.USART_Parity=USART_Parity_No;
  210.         USART_InitStrue.USART_StopBits=USART_StopBits_1;
  211.         USART_InitStrue.USART_WordLength=USART_WordLength_8b;
  212.         USART_Init(USART2,&USART_InitStrue);
  213.         
  214.         USART_Cmd(USART2,ENABLE);
  215.         
  216.         USART_ITConfig(USART2,USART_IT_RXNE,ENABLE);
  217.         
  218.         NVIC_InitStrue.NVIC_IRQChannel=USART2_IRQn;
  219.         NVIC_InitStrue.NVIC_IRQChannelCmd=ENABLE;
  220.         NVIC_InitStrue.NVIC_IRQChannelPreemptionPriority=1;
  221.         NVIC_InitStrue.NVIC_IRQChannelSubPriority=1;
  222.         NVIC_Init(&NVIC_InitStrue);
  223. }

  224. void USART2_IRQHandler(void)
  225. {
  226.         u8 Res;
  227.                 if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
  228.                 {
  229.                 Res =USART_ReceiveData(USART2);        //读取接收到的数据
  230.                
  231.                 if((USART2_RX_STA&0x8000)==0)//接收未完成
  232.                         {
  233.                         if(USART2_RX_STA&0x4000)//接收到了0x0d
  234.                                 {
  235.                                 if(Res!=0x0a)USART2_RX_STA=0;//接收错误,重新开始
  236.                                 else USART2_RX_STA|=0x8000;        //接收完成了
  237.                                 }
  238.                         else //还没收到0X0D
  239.                                 {        
  240.                                 if(Res==0x0d)USART2_RX_STA|=0x4000;
  241.                                 else
  242.                                         {
  243.                                         USART2_RX_BUF[USART2_RX_STA&0X3FFF]=Res ;
  244.                                         USART2_RX_STA++;
  245.                                         if(USART2_RX_STA>(USART2_REC_LEN-1))USART2_RX_STA=0;//接收数据错误,重新开始接收         
  246.                                         }                 
  247.                                 }
  248.                         }                    
  249.      }
  250. }
  251. #endif
  252. #endif
复制代码

usart.h

  1. #ifndef __USART_H
  2. #define __USART_H
  3. #include "stdio.h"        
  4. #include "sys.h"

  5. #define USART_REC_LEN                          200          //定义最大接收字节数 200
  6. #define EN_USART1_RX                         1                //使能(1)/禁止(0)串口1接收
  7.                   
  8. extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
  9. extern u16 USART_RX_STA;                         //接收状态标记        

  10. void uart_init(u32 bound);

  11. #define USART2_REC_LEN                          200          //定义最大接收字节数 200
  12. #define EN_USART2_RX                         1                //使能(1)/禁止(0)串口1接收

  13. extern u8  USART2_RX_BUF[USART2_REC_LEN]; //接收缓冲,最大USART2_REC_LEN个字节.末字节为换行符
  14. extern u16 USART2_RX_STA;                         //接收状态标记        

  15. void My_USART2_Init(u32 bound);

  16. #define USART3_REC_LEN                          200          //定义最大接收字节数 200
  17. #define EN_USART3_RX                         1                //使能(1)/禁止(0)串口3接收
  18.                   
  19. extern u8  USART3_RX_BUF[USART3_REC_LEN]; //接收缓冲,最大USART3_REC_LEN个字节.末字节为换行符
  20. extern u16 USART3_RX_STA;                                 //接收状态标记        

  21. void USART3_SendString(u8 *DAT,u8 len);
  22. void USART3_SendData(u8 data);
  23. void USART3_Init(u32 bound);

  24. #endif
复制代码

关于接线的话,我在main函数里面开头就已经写了。至于LD3320语音模块,他是集成在51单片机的,所以你要设置那些语音的口令以及收到口令后发送什么数据到stm32的串口2需要打开LD3320语音模块的程序,在最下面我将附上所有的程序以及资料,我个人认为里面讲得很清楚(对于LD3320语音模块以及MR628播报模块,里面相关教学视频也有)
虽然里面的51程序是MDK4的程序,但是我用MDK5打开了,所以各位如果要打开里面的51程序的话,需要用MDK5打开,因为MDK5编译后,MDK4是打不开的。
————————————————
版权声明:i土豆


收藏 评论0 发布时间:2022-10-16 18:27

举报

0个回答

所属标签

相似分享

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
STM32N6 AI生态系统
STM32MCU,MPU高性能GUI
ST ACEPACK电源模块
意法半导体生物传感器
STM32Cube扩展软件包
关注我们
st-img 微信公众号
st-img 手机版