1. Toy模板网首页
  2. > Toy博客

基于蓝牙技术使用stm32制造一个智能小车 （寻迹，避障，遥控）

7月前 作者：安知甜与乐 分类：Toy博客 阅读(28) 违法举报

这篇具有很好参考价值的文章主要介绍了基于蓝牙技术使用stm32制造一个智能小车 （寻迹，避障，遥控）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

目录

1.制作智能小车的硬件名单：

3.引脚图

2.先让小车动起来

 1.小车运动

2.代码

3.寻迹

 1.工作原理

2.代码

4.超声波避障

 1.工作原理

2.代码

5.蓝牙遥控

 1.蓝牙工作原理

2.代码

6.oled屏幕

1.工作内容

7.led灯

8.蜂鸣器

9.蓝牙使用代码main

1.制作智能小车的硬件名单：

 STM32C6T6核心板 1块
L298N电机驱动  1块
五路灰度循迹模块    1个
带电机轮子的小车底盘(自带tt电机)  1个    
12V供电电池 1个
蓝牙模块 1个
超声波 1个
电源转换模块 1个
OLED屏幕 1个
LED灯 1个
蜂鸣器 1个

1.小车底盘可以凭自己爱好买两轮或者四轮的。

2.核心板也可以凭性能改变，我觉得c6t6的已经可以完成他们了。

3.引脚图

蓝牙模块控制小车,制造小物品,stm32,制造,单片机,人工智能

蓝牙模块控制小车,制造小物品,stm32,制造,单片机,人工智能

2.先让小车动起来

蓝牙模块控制小车,制造小物品,stm32,制造,单片机,人工智能

蓝牙模块控制小车,制造小物品,stm32,制造,单片机,人工智能

 1.小车运动

前进：让所有的轮子正转。

后退：让所有的轮子反转。

左转：左侧轮子不动，右边轮子往正转。

右转：右侧轮子不动，左边轮子往反转。

2.代码

#include "motor.h"
//使用定时器2
void PWM_Init(void)
{
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2|GPIO_Pin_1;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	TIM_InternalClockConfig(TIM2);
	
	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
	TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
	TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInitStructure.TIM_Period = 100 - 1;		//ARR
	TIM_TimeBaseInitStructure.TIM_Prescaler = 36 - 1;		//PSC
	TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
	TIM_TimeBaseInit(TIM2, &TIM_TimeBaseInitStructure);
	
	TIM_OCInitTypeDef TIM_OCInitStructure;
	TIM_OCStructInit(&TIM_OCInitStructure);
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1;
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
	TIM_OCInitStructure.TIM_Pulse = 0;		//CCR
    
	TIM_OC3Init(TIM2, &TIM_OCInitStructure);
	TIM_OC2Init(TIM2, &TIM_OCInitStructure);
    
	TIM_Cmd(TIM2, ENABLE);
}

void PWM_SetCompare3(uint16_t Compare)
{
	TIM_SetCompare3(TIM2, Compare);
}

void PWM_SetCompare2(uint16_t Compare)
{
	TIM_SetCompare2(TIM2, Compare);
}

void Motor_Init(void)
{
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	
	GPIO_InitTypeDef GPIO_InitStructure;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 |GPIO_Pin_3 | GPIO_Pin_6;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	PWM_Init();
}

//TIM_SetCompare2 TIM_SetCompare3的数值分别对应左右两边的速度，可自行调整
void run(u8 s)
{

	 TIM_SetCompare2(TIM2,s);
     TIM_SetCompare3(TIM2,s);
    
     IN1 = 1;
	 IN2 = 0;
	
	 IN3 = 1;
	 IN4 = 0;
}

void back(u8 s)
{
	 TIM_SetCompare2(TIM2,s);
	 TIM_SetCompare3(TIM2,s);
	
     IN1 = 0;
	 IN2 = 1;
	
	 IN3 = 0;
	 IN4 = 1;
}

void zhuan1(u8 s)
{

	 TIM_SetCompare2(TIM2,s);
     TIM_SetCompare3(TIM2,s);
    
     IN1 = 1;
	 IN2 = 0;
	
	 IN3 = 0;
	 IN4 = 1;

}

void zhuan2(u8 s)
{

	 TIM_SetCompare2(TIM2,s);
     TIM_SetCompare3(TIM2,s);
    
     IN1 = 0;
	 IN2 = 1;
	
	 IN3 = 1;
	 IN4 = 0;

}

void right(u8 s)
{
   	 TIM_SetCompare2(TIM2,s);
 	 TIM_SetCompare3(TIM2,s);
	
     IN1 = 1;
	 IN2 = 1;
	
	 IN3 = 1;
	 IN4 = 0;
}

void left(u8 s)
{
	 TIM_SetCompare2(TIM2,s);
	 TIM_SetCompare3(TIM2,s);
	
     IN1 = 1;
	 IN2 = 0;
	
	 IN3 = 1;
	 IN4 = 1;
}


void stop()
{

     IN1 = 0;
	 IN2 = 0;
	
	 IN3 = 0;
	 IN4 = 0;
}
#ifndef __MOTOR_H
#define	__MOTOR_H
#include "bm.h"

#include "stm32f10x.h"                  // Device header
//可以按照此处接线 IN1~4

#define      IN1         PAout(6)
#define      IN2         PAout(5)
#define      IN3         PAout(4)
#define      IN4         PAout(3)

void Motor_Init(void);
void run(u8 s);
void left(u8 s);
void right(u8 s);
void back(u8 s);
void stop(void);
void zhuan1(u8 s);
void zhuan2(u8 s);

#endif

3.寻迹

蓝牙模块控制小车,制造小物品,stm32,制造,单片机,人工智能

 1.工作原理

黑色返回1，对应的灯不亮。

白色返回0，对应的灯亮。

可以用螺丝刀调节灵敏度。

2.代码

#include "xunji.h"
#include "motor.h"
#include "Delay.h"
//五路寻迹模块
void XUN_GPIO_COnfine(void)
{
  GPIO_InitTypeDef  GPIO_InitStructure;
	 
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);	  
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_4|GPIO_Pin_8|GPIO_Pin_7;		
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; 	 
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	 
  GPIO_Init(GPIOB, &GPIO_InitStructure);			     
}

extern int l;
//寻迹运动
//根据线的宽度来决定；
void run1(void )
{
            if(L2==0&&L1==0&&M==1&&R1==0&&R2==0&&l>20)
            {run(70);}
            
            else if(L2==0&&L1==1&&M==0&&R1==0&&R2==0&&l>20)
            { run(70);}
            
            else if(L2==0&&L1==0&&M==0&&R1==1&&R2==0&&l>20)
            { run(70);}
            
            else if(L2==0&&L1==0&&M==1&&R1==1&&R2==0&&l>20)
            { run(70);}
            
            else if(L2==0&&L1==1&&M==1&&R1==0&&R2==0&&l>20)
            { run(70);}
            
            else if(L2==0&&L1==1&&M==1&&R1==1&&R2==0&&l>20)
            { run(70);}
            
             else if(L2==0&&L1==1&&M==1&&R1==1&&R2==1&&l>20)
            { left(70);}
            
             else if(L2==1&&L1==1&&M==1&&R1==1&&R2==0&&l>20)
            { right(70);}
            
            
            
            else if(L2==1&&L1==0&&M==0&&R1==0&&R2==0&&l>20)
            {right(80);}
            
            else if(L2==1&&L1==1&&M==0&&R1==0&&R2==0&&l>20)
            {right(80);}
            
            else if(L2==1&&L1==1&&M==1&&R1==0&&R2==0&&l>20)
            {right(80);}
            
            else if(L2==1&&L1==0&&M==1&&R1==0&&R2==0&&l>20)
            {right(80);}
            
            else if(L2==1&&R2==0&&l<20)
            {right(80);}    
            
            
            else if(L2==0&&L1==0&&M==1&&R1==1&&R2==1&&l>20)
            {left(80);}
            
            else if(L2==0&&L1==0&&M==0&&R1==1&&R2==1&&l>20)
            {left(80);}
            
            else if(L2==0&&L1==0&&M==0&&R1==0&&R2==1&&l>20)
            {left(80);}
            
            else if(L2==0&&L1==0&&M==1&&R1==0&&R2==1&&l>20)
            {left(80);}
        
            else if(L2==0&&R2==1&&l>20)
            {left(80);}
            
            else if(L2==1&&L1==1&&M==1&&R1==1&&R2==1&&l>20)
            {           zhuan1(75);
                        Delay_ms(100);
                        
                        stop();
                        Delay_ms(500);	
            }
            
            else if(L2==0&&L1==0&&M==0&&R1==0&&R2==0&&l>20)
            {           
                        zhuan1(75);
                        Delay_ms(100);
                
                        stop();
                        Delay_ms(500);	
            }
}
#ifndef __XUNJI_H
#define __XUNJI_H

#include "stm32f10x.h"                  // Device header


#define   R2   GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_8)
#define   R1   GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_4)
#define   M    GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_5) 
#define   L1   GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_6) 
#define   L2   GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_7)
	
void XUN_GPIO_COnfine(void);
void run1(void);

#endif

4.超声波避障

蓝牙模块控制小车,制造小物品,stm32,制造,单片机,人工智能

 1.工作原理

由于超声波碰到物体返回的特点，利用两者的时间差，以及声音在空中的速度就可以计算出障碍物的距离，进行躲避。

2.代码

#include "sonic.h"

//定时器3设置
void hcsr04_NVIC()
{
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);

NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;             
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;  
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;         
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;       
NVIC_Init(&NVIC_InitStructure);
}


//IO口初始化 及其他初始化
void Hcsr04Init(void)
{  
    TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;   
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
   
    GPIO_InitStructure.GPIO_Pin =Trig_Pin;      
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
    GPIO_ResetBits(GPIOB ,Trig_Pin);
     
    GPIO_InitStructure.GPIO_Pin = Echo_Pin ;     
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOB, &GPIO_InitStructure);  
    GPIO_ResetBits(GPIOB,Echo_Pin);    
     
          
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);   
     
    TIM_DeInit(TIM3);
    TIM_TimeBaseStructure.TIM_Period = (1000-1); 
    TIM_TimeBaseStructure.TIM_Prescaler =(72-1); 
    TIM_TimeBaseStructure.TIM_ClockDivision=TIM_CKD_DIV1;
    TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;  
    TIM_TimeBaseInit(TIM3, &TIM_TimeBaseStructure);          
        
    TIM_ClearFlag(TIM3, TIM_FLAG_Update);  
    TIM_ITConfig(TIM3,TIM_IT_Update,ENABLE);    
    hcsr04_NVIC();
    TIM_Cmd(TIM3,DISABLE);     
}

u16 msHcCount = 0;
//打开定时器3
static void OpenTimerForHc()  
{
   TIM_SetCounter(TIM3,0);
   msHcCount = 0;
   TIM_Cmd(TIM3, ENABLE); 
}

//关闭定时器3
static void CloseTimerForHc()    
{
   TIM_Cmd(TIM3, DISABLE); 
}

//定时器3终中断
void TIM3_IRQHandler(void)  
{
   if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET)  
   {
       TIM_ClearITPendingBit(TIM3, TIM_IT_Update  ); 
       msHcCount++; //计数器开始加
   }
}
 

//获取定时器3计数器值
u32 GetEchoTimer(void)
{
   u32 t = 0;
   t = msHcCount*1000;
   t += TIM_GetCounter(TIM3);
   TIM3->CNT = 0;  //计数器归零
   Delay_ms(50);
   return t;
}
 
//通过定时器3计数器值推算距离
float Hcsr04GetLength(void )
{
   u32 t = 0;
   int i = 0;
   float lengthTemp = 0;
   float sum = 0;
   u8 ll=0;
    
   while(i!=5)  //测量五次取平均
   {
       for(ll=0;ll<5;ll++)
      {
      TRIG_Send = 1;   //给控制端高电平
      Delay_us(20);
      TRIG_Send = 0;  //超声波模块已开始发送8个40khz脉冲
      }
      
      while(ECHO_Reci == 0);   //若ECHO_Reci为低电平，则一直循环，直到为高电平。  
      OpenTimerForHc();       //此时说明检测到高电平，开启定时器，开始计时。       
      i = i + 1;
      while(ECHO_Reci == 1); //若ECHO_Reci为高电平，则一直循环，直到为低电平。 
      
      CloseTimerForHc();   //此时说明检测到低电平，关闭定时器，停止计时 
      
      t = GetEchoTimer();        //获取定时器时间       
      lengthTemp = ((float)t/58.0); //数据处理，转换成cm
      sum = lengthTemp + sum ;  //五次测得数据累加
        
    }
   
    lengthTemp = sum/5.0; //取平均
    return lengthTemp;
}
//超声波避障
extern int l;
void run2()
{
   
    if(l>30)
    {
        run(70);
        
    }
    
    if(l<=30)
    {
       
        back(70);
       
    }
    
    if(l<=7)
    { 
        zhuan1(75);
        Delay_ms(100);
        
        stop();
        Delay_ms(500);
       
    }
}

#ifndef __SONIC_H
#define __SONIC_H

#include "stm32f10x.h"                  // Device header
#include "BM.h"
#include "Delay.h"
#include "motor.h"

#define Trig_Pin         GPIO_Pin_0
#define TRIG_Send        PBout(0)
#define Echo_Pin         GPIO_Pin_1        
#define ECHO_Reci        PBin(1)

void Hcsr04Init(void);
float Hcsr04GetLength(void);
void run2(void);
#endif

5.蓝牙遥控

蓝牙模块控制小车,制造小物品,stm32,制造,单片机,人工智能

 1.蓝牙工作原理

  

购买回来的蓝牙模块需要进行设置时（如主从机设置、波特率、蓝牙名称以及密码修改等）:

进入AT指令方法，具体要看手册，不同模块有不同进入方法，

打开串口，设置与蓝牙模块相同波特率：

3、主、从机模式设置：

 主、从机模式需要通过设置实现（蓝牙模块都默认为从机模式，不需要改请忽略），既通过串口发送AT指令设置：

AT+ROLE设置主从模式: AT+ROLE?是查询主从状态；AT+ROLE=1是设成主；AT+ROLE=0是设成从。 

4、波特率设置：

        波特率一般默认为9600。波特率越低，传输速度越慢，但也不是越高越好，看具体情况而定，一般单片机用的都是9600。（注意：蓝牙模块的波特率需要和单片机的相同，否则传输不了数据）

这个默认波特率不是每个蓝牙模块都一样的，有的蓝牙模块默认波特率是115200，使用的时候需要看下商家资料。或者每个波特率试着改一下，总能试出来蓝牙模块的默认波特率。

指令代码部分先还有很多（比如：改蓝牙名称、蓝牙密码），感兴趣的话可以看一下数据手册，这里就不说那么多。

2.代码

include "hc_05.h"

//蓝牙
void uart1_init( u32 bound )
{
	/* GPIO端口设置 */
	GPIO_InitTypeDef	GPIO_InitStructure;
	USART_InitTypeDef	USART_InitStructure;
 
 
	RCC_APB2PeriphClockCmd( HC_05_GPIO_CLK, ENABLE ); 
	RCC_APB2PeriphClockCmd( HC_05_CLK , ENABLE );         /* 使能USART1，GPIOA时钟 */
   
	
 
    /*  TXD */
    GPIO_InitStructure.GPIO_Pin	= TX_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode	= GPIO_Mode_AF_PP;
	GPIO_Init( HC_05_GPIO_PORT, &GPIO_InitStructure );
	/* RXD */
	GPIO_InitStructure.GPIO_Pin	= RX_GPIO_PIN;
	GPIO_InitStructure.GPIO_Mode	= GPIO_Mode_IN_FLOATING;
	GPIO_Init( HC_05_GPIO_PORT, &GPIO_InitStructure );
 
 
	/* USART 初始化设置 */
	USART_InitStructure.USART_BaudRate		= bound;                                /* 串口波特率 */
	USART_InitStructure.USART_WordLength		= USART_WordLength_8b;                  /* 字长为8位数据格式 */
	USART_InitStructure.USART_StopBits		= USART_StopBits_1;                     /* 一个停止位 */
	USART_InitStructure.USART_Parity		= USART_Parity_No;                      /* 无奇偶校验位 */
	USART_InitStructure.USART_HardwareFlowControl	= USART_HardwareFlowControl_None;       /* 无硬件数据流控制 */
	USART_InitStructure.USART_Mode			= USART_Mode_Rx | USART_Mode_Tx;        /* 收发模式 */
 
	USART_Init(HC_05_USARTX, &USART_InitStructure );                                             /* 初始化串口1 */
	USART_Cmd( HC_05_USARTX, ENABLE );                                                            /* 使能串口 1 */
}

/***************** 发送一个字符  **********************/
static void Usart_SendByte( USART_TypeDef * pUSARTx, uint8_t ch )
{
	/* 发送一个字节数据到USART1 */
	USART_SendData(pUSARTx,ch);
		
	/* 等待发送完毕 */
	while (USART_GetFlagStatus(pUSARTx, USART_FLAG_TXE) == RESET);	
}


/*****************  发送字符串 **********************/
void Usart_SendString( USART_TypeDef * pUSARTx, uint8_t *str)
{
	unsigned int k=0;
    do 
    {
        Usart_SendByte( pUSARTx, *(str + k) );
        k++;
    } while(*(str + k)!='\0');
}
#ifndef __HC_05_H
#define __HC_05_H

#include "stm32f10x.h"                  // Device header

void uart1_init( u32 bound );

void Usart_SendString( USART_TypeDef * pUSARTx, uint8_t *str);
//使用宏定义容易修改串口
#define HC_05_GPIO_PORT    	GPIOA		                /* GPIO端口 */
#define HC_05_GPIO_CLK 	    RCC_APB2Periph_GPIOA		/* GPIO端口时钟 */

#define RX_GPIO_PIN	        GPIO_Pin_10	
#define TX_GPIO_PIN	        GPIO_Pin_9

#define HC_05_USARTX        USART1
#define HC_05_CLK           RCC_APB2Periph_USART1


#endif

6.oled屏幕

1.工作内容

显示距离和五路寻迹状况，还有处于那种模式。

7.led灯

#include "led.h"   

 /**
  * @brief  初始化控制LED的IO
  * @param  无
  * @retval 无
  */
void LED_GPIO_Config(void)
{		
		/*定义一个GPIO_InitTypeDef类型的结构体*/
		GPIO_InitTypeDef GPIO_InitStructure;

		/*开启LED相关的GPIO外设时钟*/
		RCC_APB2PeriphClockCmd( LED1_GPIO_CLK | LED2_GPIO_CLK|LED3_GPIO_CLK , ENABLE);
		/*选择要控制的GPIO引脚*/
		GPIO_InitStructure.GPIO_Pin = LED1_GPIO_PIN;	

		/*设置引脚模式为通用推挽输出*/
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   

		/*设置引脚速率为50MHz */   
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 

		/*调用库函数，初始化GPIO*/
		GPIO_Init(LED1_GPIO_PORT, &GPIO_InitStructure);	
		
		/*选择要控制的GPIO引脚*/
		GPIO_InitStructure.GPIO_Pin = LED2_GPIO_PIN;

		/*调用库函数，初始化GPIO*/
		GPIO_Init(LED2_GPIO_PORT, &GPIO_InitStructure);
		
        /*选择要控制的GPIO引脚*/
		GPIO_InitStructure.GPIO_Pin = LED3_GPIO_PIN;

		/*调用库函数，初始化GPIO*/
		GPIO_Init(LED3_GPIO_PORT, &GPIO_InitStructure);
		

}

/*********************************************END OF FILE**********************/
ifndef __LED_H
#define	__LED_H


#include "stm32f10x.h"


/* 定义LED连接的GPIO端口, 用户只需要修改下面的代码即可改变控制的LED引脚 */
#define LED1_GPIO_PORT    	GPIOA		                /* GPIO端口 */
#define LED1_GPIO_CLK 	    RCC_APB2Periph_GPIOA		/* GPIO端口时钟 */
#define LED1_GPIO_PIN	    GPIO_Pin_8		        

#define LED2_GPIO_PORT    	GPIOA		          /* GPIO端口 */
#define LED2_GPIO_CLK 	    RCC_APB2Periph_GPIOA		/* GPIO端口时钟 */
#define LED2_GPIO_PIN		GPIO_Pin_11			        

#define LED3_GPIO_PORT    	GPIOA			              /* GPIO端口 */
#define LED3_GPIO_CLK 	    RCC_APB2Periph_GPIOA		/* GPIO端口时钟 */
#define LED3_GPIO_PIN		GPIO_Pin_12		 

/** the macro definition to trigger the led on or off 
  * 1 - off
  *0 - on
  */
#define ON  0
#define OFF 1

/* 使用标准的固件库控制IO*/
#define LED1(a)	if (a)	\
					GPIO_ResetBits(LED1_GPIO_PORT,LED1_GPIO_PIN);\
					else		\
					GPIO_SetBits(LED1_GPIO_PORT,LED1_GPIO_PIN)

#define LED2(a)	if (a)	\
					GPIO_ResetBits(LED2_GPIO_PORT,LED2_GPIO_PIN);\
					else		\
					GPIO_SetBits(LED2_GPIO_PORT,LED2_GPIO_PIN)

#define LED3(a)	if (a)	\
				GPIO_ResetBits(LED3_GPIO_PORT,LED3_GPIO_PIN);\
					else		\
						GPIO_SetBits(LED3_GPIO_PORT,LED3_GPIO_PIN)


/* 直接操作寄存器的方法控制IO */
#define	digitalHi(p,i)		 {p->BSRR=i;}	 //输出为高电平		
#define digitalLo(p,i)		 {p->BRR=i;}	 //输出低电平
#define digitalToggle(p,i) {p->ODR ^=i;}     //输出反转状态


/* 定义控制IO的宏 */
#define LED1_TOGGLE		 digitalToggle(LED1_GPIO_PORT,LED1_GPIO_PIN)
#define LED1_OFF		   digitalHi(LED1_GPIO_PORT,LED1_GPIO_PIN)
#define LED1_ON			   digitalLo(LED1_GPIO_PORT,LED1_GPIO_PIN)

#define LED2_TOGGLE		 digitalToggle(LED2_GPIO_PORT,LED2_GPIO_PIN)
#define LED2_OFF		   digitalHi(LED2_GPIO_PORT,LED2_GPIO_PIN)
#define LED2_ON			   digitalLo(LED2_GPIO_PORT,LED2_GPIO_PIN)


#define LED3_TOGGLE	   digitalToggle(LED3_GPIO_PORT,LED3_GPIO_PIN)
#define LED3_OFF		   digitalHi(LED3_GPIO_PORT,LED3_GPIO_PIN)
#define LED3_ON			   digitalLo(LED3_GPIO_PORT,LED3_GPIO_PIN)

void LED_GPIO_Config(void);

#endif /* __LED_H */

8.蜂鸣器

#include "Buzzer.h"

void Buzzer_GPIO_Config(void)
{		
		/*定义一个GPIO_InitTypeDef类型的结构体*/
		GPIO_InitTypeDef GPIO_InitStructure;

		/*开启LED相关的GPIO外设时钟*/
		RCC_APB2PeriphClockCmd( Buzzer_GPIO_CLK , ENABLE);
		/*选择要控制的GPIO引脚*/
		GPIO_InitStructure.GPIO_Pin = Buzzer_GPIO_PIN;	

		/*设置引脚模式为通用推挽输出*/
		GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   

		/*设置引脚速率为50MHz */   
		GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 

		/*调用库函数，初始化GPIO*/
		GPIO_Init(Buzzer_GPIO_PORT, &GPIO_InitStructure);	
		//置高电平
        GPIO_SetBits(Buzzer_GPIO_PORT, Buzzer_GPIO_PIN);
}

#ifndef __Buzzer_H
#define __Buzzer_H

#include "stm32f10x.h"                  // Device header


#define Buzzer_GPIO_PORT    	GPIOA		                /* GPIO端口 */
#define Buzzer_GPIO_CLK 	    RCC_APB2Periph_GPIOA		/* GPIO端口时钟 */
#define Buzzer_GPIO_PIN	        GPIO_Pin_7	


#define Buzzer_OFF             GPIO_ResetBits(Buzzer_GPIO_PORT,Buzzer_GPIO_PIN)
#define Buzzer_ON			   GPIO_SetBits(Buzzer_GPIO_PORT,Buzzer_GPIO_PIN)
                    
void Buzzer_GPIO_Config(void);

#endif

9.蓝牙使用代码main

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include  "sonic.h"
#include "xunji.h"
#include "motor.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "led.h"
#include "hc_05.h"
#include "Buzzer.h"

u8 i=0;
int sp,l;
unsigned int receive_data;
void hc_05_send(void)
{
			if(receive_data =='a')   
			{	  
                    i=1;
                receive_data=0;
			}
            
			if(receive_data =='b')
			{
                    i=2;   
                    receive_data=0;
			}  
            if(receive_data =='c')
			{
                    i=3;    
                    receive_data=0;
			}
            if(receive_data =='d')
			{
                    i=4; 
                    receive_data=0;
			}
            if(receive_data =='e')
			{
                    i=5;  
                    receive_data=0;
			}
            if(receive_data =='f')
			{
                    i=6;    
                    receive_data=0;
			}
            
            if(receive_data =='g')
			{
                    i=7;    
                    receive_data=0;
			}
            
            if(receive_data =='k')
			{
                    i=8;    
                    receive_data=0;
			}
            
            if(receive_data =='j')
			{
                    i=9;    
                    receive_data=0;
			}
            
            if(receive_data =='l')
			{
                    i=10;    
                    receive_data=0;
			}
            if(receive_data =='p')
			{
                    i=11;    
                    receive_data=0;
			}
            if(receive_data =='v')
			{
                    i=12;    
                    receive_data=0;
			}
}

void fying(void)
{
            if(i==1)
            {
            OLED_ShowString(1,4," run");
                run(90);
            }
            
            if(i==2)
            {
            OLED_ShowString(1,4,"black");
                back(90);
            }
            
            if(i==3)
            {
            OLED_ShowString(1,4,"left  ");
                left(70);
            }
            
            if(i==4)
            {
            OLED_ShowString(1,4,"right ");
                right(70);
            }
            if(i==5)
            {
            OLED_ShowString(1,4,"zhuan1");
               zhuan1(80);
            }
            if(i==6)
            {
            OLED_ShowString(1,4," stop ");
              stop();
            }
           
             
            if(i==7)
            {
            run1();
                  OLED_ShowString(1,4," xunji");
            } 
            
            if(i==8)
            {
            
                  OLED_ShowString(1,4," LEDS ");
                LED1_OFF;LED2_OFF;LED3_OFF;
            }
            
            if(i==9)
            {
            
                  OLED_ShowString(1,4," LEDM ");
                LED1_ON;LED2_ON;LED3_ON;
            }
            if(i==10)
            {
            
                  OLED_ShowString(1,4," SONIC ");
                run2();
            }
            if(i==11)
            {
            
                  OLED_ShowString(1,4,"BUZZER");
                  Buzzer_OFF;
            }
            if(i==12)
            {
            
                  OLED_ShowString(1,4,"BUZZER");
                  Buzzer_ON;
            }
}

int main(void)
{	
 
	 
	uart1_init(9600);
    OLED_Init();
    Motor_Init();
    Hcsr04Init();
    XUN_GPIO_COnfine();
    LED_GPIO_Config();
    Buzzer_GPIO_Config();
	while(1)
	{
        
        sp= (L2* 10000) + (L1 * 1000)+ (M * 100) + (R1 * 10) + R2;
        l=Hcsr04GetLength();
        OLED_ShowNum(2,4,l,3);
        OLED_ShowNum(3,4,sp,5);
		if(USART_GetFlagStatus(HC_05_USARTX,USART_FLAG_RXNE)==1)     
		{
			receive_data=USART_ReceiveData(HC_05_USARTX); 
			
            hc_05_send();
            
            USART_ClearFlag(HC_05_USARTX,USART_FLAG_RXNE);
		}
          fying();
        if(l<10)
        {
            Buzzer_OFF;
            LED1_OFF;
        }
        if(l>10)
        {
            Buzzer_ON;
            LED1_ON;
        }
        
            
	}
	
}

-----------------------欢迎大家指正交流，有空可以一起讨论代码啊。--------------------------------

完整工程链接：通过百度网盘分享的文件：小车.zip
链接:https://pan.baidu.com/s/1dXtAi0C-9MGuAeWu13SXeQ?pwd=3gv8 
提取码:3gv8文章来源地址https://www.toymoban.com/news/detail-557382.html

到了这里，关于基于蓝牙技术使用stm32制造一个智能小车 （寻迹，避障，遥控）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 基于stm32F1的蓝牙控制小车 全硬件代码开源

    基于stm32F1的蓝牙控制小车 全硬件代码开源

       “基于stm32F1的蓝牙控制小车”由L898N电机驱动模块、电源管理模块、stm32f1主控模块、蓝牙串口通信模块。电机驱动模块使用了两个L298N芯片来驱动4路电机，使能端连接4路来自主控板的电平信号；电源管理模块使用了LM2940-5.0芯片进行12V到5V的转换，12V用于电机模块的供电，

    2023年04月20日
    浏览(38)
  • 智能小车红外测速模块的使用方法(基于STM32的标准库)

    智能小车红外测速模块的使用方法(基于STM32的标准库)

    基于STM32标准库编程实现智能小车的红外测速所需掌握的知识： （1）外部中断的配置 （2）定时器的配置 （3）串口的配置 红外测速的核心思路 ： （1）红外测速模通电后，会发出红外线，利用测速盘对红外线进行遮光，使测速模块连接STM32的中断引脚触发中断。每次发生中

    2024年02月04日
    浏览(34)
  • stm32f103基于pid的蓝牙循迹小车

    stm32f103基于pid的蓝牙循迹小车

    目录 前言 一、霍尔编码器以及定时器计数原理 二、使用pwm占空比对电机速度进行控制 三、使用systick的中断函数进行pid和速度的计算，还有oled的显示 四、常用的测速方法：  五、pid原理 六、oled的实现 七、蓝牙通信 八、3路循迹模块 总结   经过一个月对stm32的学习，终于完

    2024年02月16日
    浏览(27)
  • STM32超级蓝牙小车——基于STM32F103C8T6的多功能蓝牙小车（PID循迹、跟踪、有源蜂鸣器播放音乐、蓝牙遥控、AD采集+DMA转运等超多元素小车）

    STM32超级蓝牙小车——基于STM32F103C8T6的多功能蓝牙小车（PID循迹、跟踪、有源蜂鸣器播放音乐、蓝牙遥控、AD采集+DMA转运等超多元素小车）

    一、项目时间：2023.7.24~11.26 二、实现效果：通过蓝牙控制小车运动与模式转换                         模式一：循迹模式                         模式二：跟踪模式                         模式三：音乐模式                         模式四：控制运动模式 三、使

    2024年02月04日
    浏览(42)
  • 基于STM32声控智能小车

    基于STM32声控智能小车

    目录 一、项目需求 二、方案设计 三、实物演示视频 四、原理图 五、PCB 六、代码 七、资料清单 资料下载地址：基于STM32的声控智能小车 1.能够通过声音控制小车，小车具备语音识别功能； 2.小车实现加速、减速、转向以及前方避障功能； 3.能够根据设计路线自动行驶。 本

    2024年02月12日
    浏览(45)
  • 基于stm32的智能小车设计（一）

    基于stm32的智能小车设计（一）

    目录 一、原理简述 二、系统硬件设计 1.电机驱动选型 1.1  L298N 1.2  L9110 1.3  DRV8833 1.4 TB6612 2.系统整体硬件设计 3.stm32主控制模块 4.舵机云台 5.超声波模块 三、系统软件设计 1.系统整体软件设计 2.电机驱动及速度的控制 3.舵机云台的控制 4.超声波测距 四、实物展示 五、完整

    2024年02月02日
    浏览(33)

  • 基于STM32的智能小车--舵机云台设计

    第一章 基于STM32的智能小车方案设计 第二章 基于STM32的智能小车–电机驱动设计 第三章 基于STM32的智能小车–循迹设计 第四章 基于STM32的智能小车–避障设计

    2024年02月14日
    浏览(26)
  • 基于STM32的智能循迹避障小车实验（小车运动部分）

    基于STM32的智能循迹避障小车实验（小车运动部分）

    写在前面 这个实验是关于智能小车的实验，现在的想法就是先做出一个循迹和避障功能，后续可能会再添加一些其他的模块。 我在做这个实验之前基本了解了F1系列开发板的大部分模块，如果没有学习之前的模块，建议先学习下开发板的基本模块。 实验所需的硬件 本来是想

    2024年02月06日
    浏览(45)
  • 基于stm32的智能小车(远程控制、避障、循迹)

    基于stm32的智能小车(远程控制、避障、循迹)

    学完stm32，总是想做点东西“大显身手”一下，智能小车就成了首选项目，其核心只是就是PWM输出，I/O口引脚电平判断。 制作智能小车的硬件名单： 由于我们做的控制功能可以使用2.4G控制，也可以使用蓝牙进行控制， 两种传输方式所需购买的模块不同，已在硬件名单中加以

    2024年02月03日
    浏览(36)
  • 蓝牙小车（基于stm32f103c8t6/HAL库/CubeMX/超详细,包含代码讲解和原理图）

    蓝牙小车（基于stm32f103c8t6/HAL库/CubeMX/超详细,包含代码讲解和原理图）

    一、小车1.0——基本蓝牙小车（仅蓝牙遥控小车运动方向,本篇） 二、小车2.0——蓝牙小车PLUS(可以蓝牙控制方向+蓝牙直接调节车速) 三、小车3.0——避障小车（超声波+舵机云台） 四、小车4.0——无线手柄方向感知操控小车（mpu6050+双蓝牙透传） 五、双轮自平衡小车（HAL库版

    2023年04月09日
    浏览(36)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包