手把手教你做基于stm32的红外、语音、按键智能灯光控制（上）

已于 2023-12-04 19:48:10 修改
阅读量3.5k 收藏 119
点赞数 33
分类专栏： 手把手教你做项目 文章标签： stm32 嵌入式硬件 单片机
于 2023-12-04 19:12:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nbbskk/article/details/134779967
版权

目录：

1.系统实现目标

本文所设计的基于单片机的灯光控制系统主要由模式选择功能、手动模式和自动模式组成。

其中模式选择功能由以下功能组成：

  1. 当最小系统板上电以后，自动进入模式选择界面，通过按键和红外遥控器可以进行模式的选择，选择的模式可用通过显示屏显示。
  2. 在选择完成相应的模式以后，也可以通过按键或者红外遥控器选择进入手动模式或者自动模式，进入相应模式以后，就可以执行相应的功能。
  3. 当进入相应模式以后，如果想要切换模式，可以通过手动退出，然后继续在模式选择界面进行选择。

手动模式主要包括红外控制模式，语音控制模式和按键控制模式，下面来详细介绍一下这几种模式：

  1. 红外控制模式：使用带有红外遥控器的用户可以通过遥控器来对智能灯光进行控制。用户可以通过遥控器上的按键来打开/关闭灯光。
  2. 语音控制模式：使用语音助手的用户可以通过语音命令来控制智能灯光。用户可以说出指令，如“开灯”、“关灯”等，系统会解析语音指令并执行相应的操作。
  3. 按键控制模式：用户可以通过智能灯光控制系统配备的按键来控制灯光。
    以上三种模式都可供用户选择，并且用户可以在不同场景下，选择最为方便、快捷的方式来对智能灯光进行控制。

自动模式主要是通过红外检测传感器和光照度传感器来实现的，主要由以下功能：

  1. 当外部环境变暗的时候，光照度传感器会检测到光照度的降低并输出相应的信号，这些信号会传递给单片机进行处理，并且会使得相应的标志位进行标记。
  2. 当红外检测传感器检测到周围有人的时候，也会产生相应的信号传递给单片机，将相应的标志位进行置位。
  3. 当同时满足外部环境变暗并且周围有人的时候，这是系统会自动处理事件，将灯打开；当其中一个事件不满足的时候，灯光就会关闭。

视频演示链接：

链接: link

2.硬件选型和软件准备

2.1. 硬件选型

1.最小系统板
这次项目使用的板子是stm32f103c8t6最小系统板，这个板子在tb上都能够买到，随便一个最小系统板都可以，== 注意在买最小系统板的时候需要买一个stlink下载器来下载程序 。==
板子链接: link
在这里插入图片描述
和
在这里插入图片描述

2.显示模块
显示模块是使用的0.96英寸的OLED屏幕，注意是使用的IIC通信协议的OLED屏幕，不是使用SPI总线协议的。买的时候要看清楚。
链接: link
在这里插入图片描述
3.温湿度传感器
这次写的代码还顺便集成了检测温湿度的功能，所以要使用DHT11温湿度传感器，来采集温度。
链接: link
在这里插入图片描述
4. 红外检测模块
红外检测模块主要是用来在自动模式下检测周围环境是否有人存在的
链接: link
在这里插入图片描述
5. 红外遥控模块
红外遥控模块主要是在手动模式下来控制灯光的开关
链接: link
在这里插入图片描述
6. BH1750光照度传感器
链接: link
在这里插入图片描述
7.语音识别模块
链接: link
在这里插入图片描述
8.按键
按键是在手动模式下来实现按键控制LED灯目的的。
链接: link
在这里插入图片描述
9.LED灯珠
链接: link
在这里插入图片描述

2.2 软件准备

当我们把所有的硬件都准备完活以后，就要开始编写软件代码，编写软件代码之前，需要进行软件环境的准备，如果没有软件环境，我把软件环境放在了以下连接中：
https://download.csdn.net/download/nbbskk/87239099

3. 硬件IO表

在这里插入图片描述

4.各个模块的驱动函数

4.1. 红外遥控模块

红外遥控模块在手动模式下进行模式切换和手动开关灯。
.c文件

#include "remote.h"
#include "oled.h"

extern uint32_t flag_auto_manu;//自动模式，手动模式切换代码
extern uint32_t flag_in_system;//进入自动模式，手动模式的标志位
extern uint32_t flag_break_mode;//退出模式的标志位
extern uint32_t flag_led_on_off;//LED灯亮灭标志位
 
void Remote_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    TIM_TimeBaseInitTypeDef Tim_TimeBaseStructure;
    TIM_ICInitTypeDef TIM_ICStructure;
    NVIC_InitTypeDef NVIC_InitStructure;
    
    RCC_APB2PeriphClockCmd( IR_GPIOx_LCK, ENABLE );             //使能端口x时钟
    RCC_APBxPeriphClockCmd( TIMx_LCK, ENABLE );                 //使能TIMx时钟
 
    GPIO_InitStructure.GPIO_Pin = IR_IO;                        //输入IO口 
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;		//浮空输入 
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init( IR_GPIOx, &GPIO_InitStructure );                 //初始化I0口
 
/*--------------------时基结构体初始化-----------------------------*/
    Tim_TimeBaseStructure.TIM_Period = (10000-1);                           //设定计数器自动重装值 最大10ms溢出  
    Tim_TimeBaseStructure.TIM_Prescaler = (72-1);                           //预分频器,1M的计数频率,1us加1.   
    Tim_TimeBaseStructure.TIM_ClockDivision = TIM_CKD_DIV1;             //设置时钟分频系数
    Tim_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;         //TIM向上计数模式
    //Tim_TimeBaseStructure.TIM_RepetitionCounter = 0;                  //重复计数设置,高级计时器才有
    TIM_TimeBaseInit( IR_TIME, &Tim_TimeBaseStructure );                //初始化 TIMx定时器
 
/*--------------------输入捕获结构体初始化--------------------------*/
    TIM_ICStructure.TIM_Channel = TIM_Channel_x;                        //配置输入捕获的通道，根据具体的 GPIO 来配置
    TIM_ICStructure.TIM_ICPolarity = TIM_ICPolarity_Rising;             //上升沿捕获
    TIM_ICStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;         //捕获输入通道选择
    TIM_ICStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;                   //不分频，每个变化沿都捕获 
    TIM_ICStructure.TIM_ICFilter = 0;                                   //被捕获的信号的滤波系数                                   
    TIM_ICInit( IR_TIME, &TIM_ICStructure );                            //初始化 定时器输入捕获
 
/*--------------------中断优先级配置--------------------------------*/
    NVIC_PriorityGroupConfig( NVIC_PriorityGroup_x );                   //设置中断组为 0
    NVIC_InitStructure.NVIC_IRQChannel = TIMx_IRQn;                     //设中断源
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;           //抢占优先级0级
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;                  //子优先级1级
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                     //使能IRQ通道
    NVIC_Init( &NVIC_InitStructure );                                   //初始化NVIC寄存器
    
    TIM_ClearFlag( IR_TIME, TIM_IT_Update|TIM_IT_CCx );                 // 清除更新和捕获中断标志位
    TIM_Cmd( IR_TIME, ENABLE );                                         //使能定时器x
    TIM_ITConfig( IR_TIME, TIM_IT_Update|TIM_IT_CCx, ENABLE );          // 开启更新和捕获中断    
    
}
 
u8  IRdatas = 0;                //接收到数据次数
u8  IRval  = 0;                 //接收到的按键值           
u8  RmtCnt = 0;                 //按键重复按下的次数
u8  Remote = 0;                 //遥控按键处理值，全局变量
TIM_ValueTypeDef TIM_Values;    //初始化结构体 
 
void TIMx_IRQHandler(void)                              //定时器x中断服务程序
{
    if ( TIM_GetITStatus( IR_TIME, TIM_IT_Update ) != RESET )
    {
        if ( TIM_Values.DataFlag == 1 )                 //是否接收到了引导码
        {
            if( TIM_Values.Period > 3 )                 //如果4次溢出中断（40ms）没收到数据，则要么开始收重复码，要么数据收完了
            {
                if( RmtCnt == 0 || TIM_Values.Period > 9 )                          //如果收到了领导码，且在4次溢出中间没有收到重复码，则判断收完数据，清0标志退出                                                       
                    TIM_Values.DataFlag = 0;                                                //或者收到重复码，且中间90ms没再触发中断，则判断收完数据，清0退出
            }
            TIM_Values.Period++;
        }
    } 
    if ( TIM_GetITStatus( IR_TIME, TIM_IT_CCx ) != RESET )                              //发生了上升沿或者下降沿事件?
    {
        if ( TIM_Values.StartFlag == 0 )                            //第一次上升沿捕获
        {   
            TIM_SetCounter( IR_TIME, 0 );                               //清0计数器
            TIM_OCxPolarityConfig( IR_TIME, TIM_ICPolarity_Falling );       //设置为下降沿捕获
            TIM_Values.CrrValue = 0;                //捕获值清0             
            TIM_Values.StartFlag = 1;               //开始下降沿捕获
            TIM_Values.Period = 0;              //自动重装载寄存器清0
        }
        else                //第二次捕获，下降沿捕获
        {
            TIM_Values.CrrValue = TIM_GetCapturex( IR_TIME );           //获取通道4 捕获寄存器的值
            TIM_OCxPolarityConfig( IR_TIME, TIM_ICPolarity_Rising );                        //设置为上升沿捕获
            TIM_Values.StartFlag = 0;                                   //开始标志复0，重新判断捕获上升沿
            TIM_Values.FinishFlag = 1;                                  //标记完成1次捕获流程
 
            if ( TIM_Values.FinishFlag == 1 )                           //判断是否完成一次捕获流程
            {
                if ( TIM_Values.DataFlag == 1 )                                     //是否接收到了引导码
                {
                    if ( TIM_Values.CrrValue > 300 && TIM_Values.CrrValue < 800 )           //560为标准值,560us
                    {
                        TIM_Values.Data <<= 1;                  //左移一位
                        TIM_Values.Data |= 0;                   //接收到0
                        IRdatas++;                      //接收到的数据次数加1.
                    }
                    else if ( TIM_Values.CrrValue > 1400 && TIM_Values.CrrValue < 1800 )    //1680为标准值,1680us
                    {
                        TIM_Values.Data <<= 1;                  //左移一位
                        TIM_Values.Data |= 1;                   //接收到1
                        IRdatas++;              //接收到的数据次数加1
                    }
 
                    /*这是 NEC 码规定的110ms连发码(由 9ms 低电平+2.5m 高电平+0.56ms 低电平
                    +97.94ms 高电平组成)，如果在一帧数据发送完毕之后，按键仍然没有放开，则发射重复码，
                    即连发码，可以通过统计连发码的次数来标记按键按下的长短/次数。结束码 ：0.56ms 高电平*/
 
                    else if ( TIM_Values.CrrValue > 2100 && TIM_Values.CrrValue < 2500 )    //得到按键键值增加的信息 2250为标准值2.25ms
                    {
                        if( RmtCnt > 3 )            //防止松开慢而误收到重复码，而抛弃前3次收到的重复码 
                            IRdatas++;              //接收到的数据次数加1
                        RmtCnt++;                   //按键次数增加1次  
                    }   
                }   
                else if ( TIM_Values.CrrValue > 4200 && TIM_Values.CrrValue < 4700 )        //4500为标准值4.5ms
                {
                    TIM_Values.DataFlag = 1;            //成功接收到了引导码,数据开始标志为1
                    IRdatas = 0;                        //等于1时收到引导码
                    RmtCnt = 0;                         //清除按键次数计数器
                    
                }
            }
            
/*---------------------------------------接收数据处理---------------------------------------*/
            
            switch ( IRdatas )      
            {
//              case 8:     //接收完特征码
//                  if( TIM_Values.Data != IR_ID )                      //如果接收到的特征码和使用遥控器不相同,则数据全部清0重来
//                  {
//                      IRdatas = 0;                    //接收数据次数清0
//                      TIM_Values.DataFlag = 0;        //开始接收数据标志复位为0  
//                  }
//                  TIM_Values.Data = 0;                //接收到的数据清0，只需要数据码
//                  break;
 
                case 16:    //接收完特征反码
                    //if ( (u8)~TIM_Values.Data != IR_ID )                  //如果知道遥控ID，想只能特定遥控器控制，则用这句与上面一句
                    if ( (u8)(TIM_Values.Data>>8) != (u8)~(TIM_Values.Data&0xff) )      //如果特征码和收到的特征反码，比较发现不同，则数据全部清0重来
                    {
                        IRdatas = 0;                    //接收数据次数清0
                        TIM_Values.DataFlag = 0;        //开始接收数据标志复位为0
                    }
                    TIM_Values.Data = 0;                //接收到的数据清0
                    break;
 
                case 24:    //接收完数据码
                    IRval = TIM_Values.Data;        //把数据码存到IRval
                    TIM_Values.Data = 0;            //接收到的数据清0，准备接收数据反码
                    break;
 
                case 32:    //接收完数据反码
                    if ( IRval != (u8)~TIM_Values.Data )        //如果数据码和接收到的数据反码不同，则数据码清0,重新开始
                    {
                        IRdatas = 0;                    //接收数据次数清0
                        IRval = 0;                      
                    }
                    TIM_Values.Data = 0;            //接收到的数据清0，准备接收下一次中断数据
                    Remote = IRval;          //把收到的按键值赋值给全局变量 Remote
                    IRdatas = 33;            //赋值为33防止在结束码时再进入中断，触发32的判断，导致数据清0
                    break;
                    
                case 34:    //重复码,如果想x个重复码算收到1次重复按键，就把34＋x                  
                    Remote = IRval;
                    IRdatas = 33;            //重新赋值回33，防止重复按键次数太多，导致数值溢出，且不需要写后面的switch选择
                    break;
            }            
        }
    }
    TIM_ClearITPendingBit( IR_TIME, TIM_IT_Update | TIM_IT_CCx );       //清除中断标志位
}
 
//移植时根据不同的遥控按键值，更改case
void Remote_Scan( u8 str )              //遥控按键处理
{        
    Remote = 0;
    switch( str )
    {
            case 0XA2:
              	OLED_ShowNum(10,10,1,3,16,1);
				OLED_Refresh();
                break;
            case 0X68:
                 OLED_ShowNum(10,10,2,3,16,1);
				OLED_Refresh();
                break;  
            case 0X30:
				OLED_ShowNum(10,10,3,3,16,1);
				OLED_Refresh();
                break;
               
            case 0X18:
//				 OLED_ShowNum(10,10,4,3,16,1);
//				OLED_Refresh();
			     flag_led_on_off=!flag_led_on_off;//按下上键以后，选择开灯或者关灯
                break;
                //LCD_ShowString( 30, 70,"I SEE YOU" );  // 显示字符串
//                break;
            case 0x7A:
				 OLED_ShowNum(10,10,5,3,16,1);
				OLED_Refresh();
                //LCD_Image( 0, 0, 240, 135, imageLoge );
                break;
            case 0x10:
			     flag_auto_manu=!flag_auto_manu;//按下左键以后，选择自动模式和手动模式切换
                break;
            case 0x38://按下OK键以后，进入这个模式
				flag_in_system=1;
                break;
            case 0x5A:
				flag_break_mode=1;//按下右键以后，模式退出
                break;
            case 0x42:
				 OLED_ShowNum(10,10,9,3,16,1);
				OLED_Refresh();
                //LED_GPIO_Confing();
                //time = 0;
                //LCD_ShowNum( 100, 55, time, sizeof(time)-1 );
                break;            
    }
}

void remote_receive(void)
{
	if( Remote != 0 )              //如果变量里面有值则代表收到遥控按键了，如果有遥控按键值为0就需要改Remote的初始值和这里的判断了  
        {
            Remote_Scan( Remote );     //遥控按键处理
        }  
}

.h文件

#ifndef _REMOTE_H
#define _REMOTE_H
 
#include "stm32f10x.h"
 
//程序用到的是TIM4_CH4，移植时只需要改这里的IO口就可以了
#define IR_TIME         TIM3        //哪个时钟
#define TIM_Channel_x   TIM_Channel_3                           //配置输入捕获的通道，根据具体的 GPIO 来配置
#define RCC_APBxPeriphClockCmd  RCC_APB1PeriphClockCmd          //TIMx时钟使能函数，TIM在APBx?
 
#define TIMx_LCK        RCC_APB1Periph_TIM3               //TIMx的时钟
#define IR_GPIOx_LCK    RCC_APB2Periph_GPIOB             //红外输入IO口的时钟
#define IR_GPIOx        GPIOB                             //红外输入IO口
#define IR_IO           GPIO_Pin_0
 
// 中断相关宏定义
#define TIM_IT_CCx              TIM_IT_CC3                           //捕获中断
#define TIMx_IRQn               TIM3_IRQn                            //设触发中断源,不同的中断中断源不一样，IRQn_Type
#define TIMx_IRQHandler         TIM3_IRQHandler                      //TIMx的触发中断服务函数
 
// 捕获信号极性函数宏定义
#define TIM_GetCapturex            TIM_GetCapture3             //对应寄存器CRRx，获取寄存器的值,该寄存器用来存储捕获发生时， TIMx_CNT的值
#define TIM_OCxPolarityConfig      TIM_OC3PolarityConfig        //OCxPolarity即TIMX通道X的极性，上升下降中心对齐
#define NVIC_PriorityGroup_x       NVIC_PriorityGroup_2         //设置中断组2，（ 2:2 ）
 
#define IR_ID          0x80                         //遥控器ID识别码
 
typedef struct {
    uint8_t     FinishFlag;        // 捕获高电平结束标志位
    uint8_t     StartFlag;         // 捕获开始标志位
    uint16_t    CrrValue;          // 捕获寄存器的值
    uint16_t    Period;            // 自动重装载寄存器更新标志,产生了多少次中断
    uint8_t     DataFlag;          // 收到引导码标志
    uint16_t    Data;              // 接收到的数据
 
} TIM_ValueTypeDef;
 
 
 
void Remote_Init(void);                //红外初始化
void TIMx_IRQHandler(void);            //定时器TIMx中断服务函数
void Remote_Scan( u8 str );            //遥控按键处理  
void remote_receive(void);
 
 
#endif /* _REMOTE_H */

4.2. 按键模块

按键模块主要是用来在手动模式下进行模式切换和按键开关LED用
.c文件

#include "stm32f10x.h"                  // Device header
#include "delay.h"
#include "key.h"


extern uint32_t flag_auto_manu;//选择自动模式或者手动模式的标志位
extern uint32_t flag_in_system;
extern uint32_t flag_break_mode;
extern uint32_t flag_led_on_off;

void key_mode_option_init(void)//PA2引脚初始化
{
	GPIO_InitTypeDef    GPIO_InitStructure;
	EXTI_InitTypeDef      EXTI_InitStructure;
	NVIC_InitTypeDef     NVIC_InitStructure;
	
	//开启时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
	
	//配置GPIO
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_2;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,& GPIO_InitStructure);
	
	//配置AFIO
	GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource2);

	
	//配置EXIT
	EXTI_InitStructure.EXTI_Line=EXTI_Line2;
	EXTI_InitStructure.EXTI_LineCmd=ENABLE;
	EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
	EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Falling;	
	EXTI_Init(&EXTI_InitStructure);
	
	
	//配置NVIC
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	NVIC_InitStructure.NVIC_IRQChannel=EXTI2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=2;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=2;
	 NVIC_Init(&NVIC_InitStructure);
}


void key_mode_in_init(void)//PA3引脚初始化
{
	GPIO_InitTypeDef    GPIO_InitStructure;
	EXTI_InitTypeDef      EXTI_InitStructure;
	NVIC_InitTypeDef     NVIC_InitStructure;
	
	//开启时钟
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);
	
	//配置GPIO
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_3;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,& GPIO_InitStructure);
	
	//配置AFIO
	GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource3);
	
	
	//配置EXIT
	EXTI_InitStructure.EXTI_Line=EXTI_Line3;
	EXTI_InitStructure.EXTI_LineCmd=ENABLE;
	EXTI_InitStructure.EXTI_Mode=EXTI_Mode_Interrupt;
	EXTI_InitStructure.EXTI_Trigger=EXTI_Trigger_Falling;	
	EXTI_Init(&EXTI_InitStructure);
	
	
	//配置NVIC
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	NVIC_InitStructure.NVIC_IRQChannel=EXTI3_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd=ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=1 ;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority=2;
	NVIC_Init(&NVIC_InitStructure);
}


void EXTI2_IRQHandler(void)//PA2引脚中断
{
	delay_ms(10);
	if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_2) == 0)
	{
		flag_auto_manu=!flag_auto_manu;//触发中断以后，手动模式和自动模式相互切换
		flag_break_mode=1;//如果已经进入模式以后，按下这个键可以退出，重新进入模式选择界面
	}
		
	
	EXTI_ClearITPendingBit(EXTI_Line2);//清除中断标志位
}


void EXTI3_IRQHandler(void)//PA3引脚中断
{
	delay_ms(10);
	if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_3) == 0)
	{
		flag_in_system=1;//按下这个键后，可以进入这个模式
		flag_led_on_off=!flag_led_on_off;//当进入手动模式以后，按下这个键，可以切换LED灯的亮灭
	}
		
	EXTI_ClearITPendingBit(EXTI_Line3);
}

.h文件

#ifndef   __KEY_H
#define  __KEY_H


void key_mode_option_init(void);
void key_mode_in_init(void);



#endif

4.3. LED灯

LED灯自然就是要控制的部件了
.c文件

#include "stm32f10x.h"                  // Device header
#include "LED.h"

void  LED_Init(void)
{
	GPIO_InitTypeDef   GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_0;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	
	GPIO_Init(GPIOA,&GPIO_InitStructure);
	GPIO_ResetBits(GPIOA,GPIO_Pin_0);
}


void  LED1_on(void)
{
	GPIO_SetBits(GPIOA,GPIO_Pin_0);
}
void  LED1_off(void)
{
	GPIO_ResetBits(GPIOA,GPIO_Pin_0);
}

.h文件

#ifndef    __LED_H
#define   __LED_H

void  LED_Init(void);
void  LED1_on(void);
void  LED1_off(void);




#endif

4.4. BH1750光照度传感器

.c文件

#include "delay.h"
#include "bh1750.h"

typedef   unsigned char BYTE;

void Single_Write_BH1750(uchar REG_Address)
{
   IIC_Start();                  //起始信号
   IIC_Send_Byte(BHAddWrite);   //发送设备地址+写信号
   IIC_Send_Byte(REG_Address);    //内部寄存器地址，
   IIC_Stop();                   //发送停止信号
}

void BH1750_GPIO_Init(void)       //BH1750 GPIO的初始化
{
    GPIO_InitTypeDef  GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);     //使能端口时钟
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7;     
     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;          //推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//速度50MHz
     GPIO_Init(GPIOB, &GPIO_InitStructure);      
     GPIO_SetBits(GPIOB,GPIO_Pin_6|GPIO_Pin_7);    
}

void BH1750_Config_Init(void)              //BH1750配置初始化
{
    BH1750_GPIO_Init();            //GPIO引脚配置
    Single_Write_BH1750(0x01);    //是一个信号，打开设备的信号 我的理解，，没看原理
}

void bh_data_send(u8 command)           
{
    do{
    IIC_Start();                      //iic起始信号
    IIC_Send_Byte(BHAddWrite);       //发送器件地址
    }while(IIC_Wait_Ack());           //等待从机应答
    IIC_Send_Byte(command);          //发送指令
    IIC_Wait_Ack();                   //等待从机应答
    IIC_Stop();                       //iic停止信号
}

u16 bh_data_read(void)
{
    u16 buf;
    IIC_Start();                       //iic起始信号
    IIC_Send_Byte(BHAddRead);         //发送器件地址+读标志位
    IIC_Wait_Ack();                     //等待从机应答
    buf=IIC_Read_Byte(1);              //读取数据
    buf=buf<<8;                        //读取并保存高八位数据
    buf+=0x00ff&IIC_Read_Byte(0);      //读取并保存低八位数据
    IIC_Stop();                        //发送停止信号 
    return buf; 
}


/*******************************
下面的都是 IIC 的一些操作  1113lc
***********************************/
//产生IIC起始信号
void IIC_Start(void)
{
    SDA_OUT();     //sda线输出
    IIC_SDA=1;            
    IIC_SCL=1;
    delay_us(4);
     IIC_SDA=0;//START:when CLK is high,DATA change form high to low 
    delay_us(4);
    IIC_SCL=0;//钳住I2C总线，准备发送或接收数据 
}      
//产生IIC停止信号
void IIC_Stop(void)
{
    SDA_OUT();//sda线输出
    IIC_SCL=0;
    IIC_SDA=0;//STOP:when CLK is high DATA change form low to high
     delay_us(4);
    IIC_SCL=1; 
    IIC_SDA=1;//发送I2C总线结束信号
    delay_us(4);                                   
}
//等待应答信号到来
//返回值：1，接收应答失败
//        0，接收应答成功
u8 IIC_Wait_Ack(void)
{
    u8 ucErrTime=0;
    SDA_IN();      //SDA设置为输入  
    IIC_SDA=1;delay_us(1);       
    IIC_SCL=1;delay_us(1);     
    while(READ_SDA)
    {
        ucErrTime++;
        if(ucErrTime>250)
        {
            IIC_Stop();
            return 1;
        }
    }
    IIC_SCL=0;//时钟输出0        
    return 0;  
} 
//产生ACK应答
void IIC_Ack(void)
{
    IIC_SCL=0;
    SDA_OUT();
    IIC_SDA=0;
    delay_us(2);
    IIC_SCL=1;
    delay_us(2);
    IIC_SCL=0;
}
//不产生ACK应答            
void IIC_NAck(void)
{
    IIC_SCL=0;
    SDA_OUT();
    IIC_SDA=1;
    delay_us(2);
    IIC_SCL=1;
    delay_us(2);
    IIC_SCL=0;
}                                          
//IIC发送一个字节
//返回从机有无应答
//1，有应答
//0，无应答              
void IIC_Send_Byte(u8 txd)
{                        
    u8 t;   
    SDA_OUT();         
    IIC_SCL=0;//拉低时钟开始数据传输
    for(t=0;t<8;t++)
    {              
        //IIC_SDA=(txd&0x80)>>7;
        if((txd&0x80)>>7)
            IIC_SDA=1;
        else
            IIC_SDA=0;
        txd<<=1;       
        delay_us(2);   //对TEA5767这三个延时都是必须的
        IIC_SCL=1;
        delay_us(2); 
        IIC_SCL=0;    
        delay_us(2);
    }     
}         
//读1个字节，ack=1时，发送ACK，ack=0，发送nACK   
u8 IIC_Read_Byte(unsigned char ack)
{
    unsigned char i,receive=0;
    SDA_IN();//SDA设置为输入
    for(i=0;i<8;i++ )
    {
        IIC_SCL=0; 
        delay_us(2);
        IIC_SCL=1;
        receive<<=1;
        if(READ_SDA)receive++;   
        delay_us(1); 
    }                     
    if (!ack)
        IIC_NAck();//发送nACK
    else
        IIC_Ack(); //发送ACK   
    return receive;
}

.h文件

#ifndef  __BH1750_H
#define __BH1750_H

//IO方向设置
#define SDA_IN()  {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)8<<28;}       
#define SDA_OUT() {GPIOB->CRL&=0X0FFFFFFF;GPIOB->CRL|=(u32)3<<28;}

#define IIC_SCL    PBout(6) //SCL
#define IIC_SDA    PBout(7) //SDA     
#define READ_SDA   PBin(7)  //输入SDA 
#define ADDR 0x23//0100011
#define uchar unsigned char 

#define BHAddWrite     0x46      //从机地址+最后写方向位
#define BHAddRead      0x47      //从机地址+最后读方向位
#define BHPowDown      0x00      //关闭模块
#define BHPowOn        0x01      //打开模块等待测量指令
#define BHReset        0x07      //重置数据寄存器值在PowerOn模式下有效
#define BHModeH1       0x10      //高分辨率 单位1lx 测量时间120ms
#define BHModeH2       0x11      //高分辨率模式2 单位0.5lx 测量时间120ms
#define BHModeL        0x13      //低分辨率 单位4lx 测量时间16ms
#define BHSigModeH     0x20      //一次高分辨率 测量 测量后模块转到 PowerDown模式
#define BHSigModeH2    0x21      //同上类似
#define BHSigModeL     0x23      // 上类似

//BH1750 功能函数
void BH1750_Config_Init(void);
void bh_data_send(u8 command);
u16 bh_data_read(void);

//IIC所有操作函数    这些是必须要声明的，因为在c文件内部实现，顺序问题，在使用之前，必须对IIC函数声明，，           
void IIC_Start(void);                //发送IIC开始信号
void IIC_Stop(void);                  //发送IIC停止信号
void IIC_Send_Byte(u8 txd);            //IIC发送一个字节
u8 IIC_Read_Byte(unsigned char ack);//IIC读取一个字节
u8 IIC_Wait_Ack(void);                 //IIC等待ACK信号
void IIC_Ack(void);                    //IIC发送ACK信号
void IIC_NAck(void);                //IIC不发送ACK信号




#endif

4.5. 红外检测模块

红外检测模块就是用来在自动模式下检测周围环境是否有人存在的。
.c文件

#include "stm32f10x.h"                  // Device header
#include "infrared.h"

uint32_t flag_infrared=0;


void infrared_Init(void)
{
	GPIO_InitTypeDef    GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	//配置GPIO
	GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Pin=GPIO_Pin_4;
	GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,& GPIO_InitStructure);
}

void infrared_read(void)
{
	if(GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_4)==0)//如果检测到引脚是低电平，说明有人
	{
		flag_infrared=1;
	}
	else//如果是高电平，则说明没人
	{
		flag_infrared=0;
	}
}

.h文件

#ifndef   __INFRARED_H
#define  __INFRARED_H

void infrared_Init(void);
void infrared_read(void);



#endif

** 需要源码可以私信我！！！**

嵌入式进阶之路
关注
  • 33
    点赞
  • 踩
  • 119
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
STM32 红外遥控
07-07
STM32 红外遥控,用stm32f103系列单片机红外接收的实验。
手把手教你图形化玩转STM32智能硬件开发.pdf
05-31
手把手教你图形化玩转STM32智能硬件开发，降低学习门槛！
STM32 F103C8T6学习笔记12：红外遥控—红外解码-位带操作
NULL指向我的博客
08-22 4659
今日学习一下红外遥控的解码使用，红外遥控在日常生活必不可少，它的解码与使用也是学习单片机的一个小过程，我们将通过实践来实现它。 文章提供源码、测试工程下载、测试效果图。
基于stm32单片机的智能台灯设计(语音控制+OLED显示)
最新发布
MCUFANS123的博客
03-05 903
7、在自动模式下，首先要检测到有人，才进行亮度的自动控制，否则台灯熄灭。可以挡住光敏电阻的光线，或用手电筒来照射光敏电阻，模拟光照的变化，从而就可以 看到台灯的亮度会随着环境中的光照强度的改变而改变，效果是光照越弱，台灯越亮。STM32F103C8T6单片机最小系统板，OLED显示模块，红外热释人体传感器，LED指示灯模块，USB台灯，光敏电阻，按键电路，语音识别模块。第四行显示台灯亮度等级；9、除了按键控制外，也可以通过语音对台灯进行控制，用户可发出“自动”、“手动”、“定时”等指令对台灯状态进行切换；
STM32智能语音控制电机
m0_63764380的博客
11-21 2477
m。
毕业/课程设计——基于STM32的智能灯光控制系统（物联网、智能家居、手机APP控制、语音控制）
热门推荐
m0_59113542的博客
12-12 3万+
物联网、智能家居、云平台、自制APP 本系统包含以下六方面功能：1、手机APP远程控制 2、语音控制 3、手机app查看家中的温度 湿度信息 4、超声波坐姿监测 5、OLED显示系统当前状态 6、万年历（支持按键修改时间）
（STM32）红外遥控
05-12
int main(void) { u8 key; delay_init(); //延时函数初始化 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级 uart_init(115200); //串口初始化为115200 LED_Init(); //LED端口初始化 KEY_Init(); Remote_Init(); //红外接收初始化 while(1) { key=Remote_Scan(); if(key) { printf("键值为：%d",key); //显示键值 switch(key) { case 0:LED0 = 0;break; case 162:LED0 = 1;break; } }else delay_ms(10); } }
基于stm32的红外遥控
qq_57628024的博客
12-08 509
发出来的信号一般有较宽的频谱，而且都是在比较低的频率段分布大量的能量，所以称之为基带信号，这种信号是不适合直接在信道中传输的。近红外光波长0.76um~1.5um ，红外遥控收发器件波长一般为 0.8um~0.94um ，具有传输效率高，成本低，电路实现简单，抗干扰强等特点，在家用电器上被广泛使用。比如我们的红外遥控信号要发送的时候，先经过38K调制，如图1所示。调制载波频率一般在30KHz到60KHz之间，常用的载波有33K，36K，36.6K，38K，40K，56K等，其中38K使用最多。
嵌入式 STM32 红外遥控
Lushengshi的博客
02-27 1087
一个脉冲对应 560us 的连续载波，一个逻辑 1 传输需要 2.25ms（560us 高+1680us 低），一个逻辑 0 的传输需要 1.125ms（560us 高+560us 低）。而红外接收头在收到脉冲的时候为低电平，在没有脉冲的时候为高电平，这样，我们在接收头端收到的信号为：逻辑 1 应该是 560us 低+1680us 高，逻辑 0 应该是 560us 低+560us高(接受头接受到的电平值取反)。NEC 遥控指令的数据格式。
29.STM32红外遥控器
qq_54674051的博客
09-25 2423
29.STM32红外遥控器
stm32 红外遥控实现
zouxin_88的专栏
05-27 7044
一、概述 红外遥控采用NEC协议 定时中断 预分频器采用72，72M/72=1M，每秒1千次，一次1us，即第1us计数器加1 。 溢出值设为10000，即10ms，发生一次TIM_IT_Update中断。 捕获中断 初始为上升沿中断。 二、代码执行过程 1.初始为上升沿捕获，收到脉冲9ms结束时为上升沿，执行上升沿捕获中断 动作：设置为下降沿捕获，清空定时器值、标记上升沿已经被捕获 2.4.5ms高电平后为下降沿，执行下降沿捕获中断 动作：设置为上升沿捕获，获取上...
【代码分享】手把手教你：基于TensorFlow的语音识别系统
03-31
本文主要介绍如何使用python搭建一个：基于TensorFlow的语音识别系统。 本文主要分为3部分： - 1、项目数据集介绍。 - 2、项目功能及相关代码展示。 - 3、项目完整下载地址。 博主也参考过语音识别系统相关模型...
STM32的红外遥控程序，亲测能用
11-24
STM32的红外遥控程序，亲测能用。内有详细的讲解文档，很好的学习资料。
STM32红外遥控实验
01-16
STM32控制红外遥控，程序简单清晰，可有效移植到其他开发板进行研发使用。
基于STM32的红外遥控实验
08-09
本章，我们将向大家介绍如何通过STM32来解码红外遥控器的信号。ALIENTK战舰STM32开发板标配了红外接收头和一个很小巧的红外遥控器。在本章中，我们将利用STM32的输入捕获功能，解码开发板标配的这个红外遥控器的编码信号，并将解码后的键值TFTLCD模块上显示出来。
STM32 红外遥控器程序
10-12
STM32 红外遥控器的全套代码，包括了红外遥控器信号的接收与发送等。
手把手教你_从STM32F4xx移植到GD32F4xx.rar
12-21
包括GD32F450xx_Datasheet_Rev1.1 & GD32F4xx_User_Manual_EN_V2.2-2 & GD32F4xx_Firmware_Library_V2.1.0 & 从STM32F4xx移植到GD32F4xx的移植说明
手把手教你如何实现自动固件更新（基于STM32+W5500）
01-26
手把手教你如何实现自动固件更新，分为嵌入式篇，服务器篇。并提供详细说明和代码
教程手把手教你做问答系列答案.docx
01-09
这是教程手把手教你做问答系列的资源。 系列专题：https://blog.csdn.net/weixin_43233491/category_9656513.html
手把手教你基于tensorflow语音识别
05-02
基于TensorFlow的语音识别可以让我们通过声音控制计算机，常常被用于开发语音助手、音视频处理等应用。以下是一步步手把手教你实现基于TensorFlow的语音识别。 1.准备数据 语音识别模型需要大量的音频数据来训练，因此首先需要准备好相关数据。可以从网上下载开源的音频数据集，也可以收集自己的数据集。 2.数据预处理 对于音频数据，需要对其进行预处理，包括语音信号的数字化和特征提取等。可以使用Python中的librosa库来完成这个过程。 3.搭建模型 使用TensorFlow来搭建语音识别模型。可以使用CNN、RNN、Transformer等不同的结构来实现。 4.训练模型 将准备好的训练集数据喂入模型中进行训练。可以使用Adam等常用优化器，同时要注意设置正确的损失函数，比如交叉熵等。 5.模型评估 训练完成后，需要对模型进行评估，包括计算识别率、准确率、召回率等评价指标。 6.模型应用 将训练好的模型应用于实际场景中，比如制作一个能够语音控制电器开关的小程序。 总之，基于TensorFlow的语音识别需要经过数据准备、预处理、建模、训练、评估和应用等多个步骤。只有掌握了这些技能，才能够实现真正实用的语音识别应用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

嵌入式进阶之路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值