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

已于 2024-04-04 20:36:34 修改
阅读量8.8k 收藏 374
点赞数 35
分类专栏： 制造小物品 文章标签： stm32 制造 单片机 人工智能
于 2023-04-12 17:04:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ssjsjss/article/details/130108790
版权

目录

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.引脚图

2.先让小车动起来

 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.寻迹

 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.超声波避障

 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.蓝牙遥控

 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

有偿回答可以加QQ：1521354774

安知甜与乐
关注
  • 35
    点赞
  • 踩
  • 374
    收藏
    觉得还不错? 一键收藏
  • 25
    评论
专栏目录
stm32f103c8t6智能小车红外循迹避障实验程序源代码.rar
12-31
该程序源代码用于stm32f103c8t6智能小车红外循迹避障实验。 1、源代码开发软件：KEIL4； 2、程序对应处理器是：STM32F103C8T6； 3、智能小车电机驱动芯片是：L293D； 4、智能小车电机为：TT直流减速电机； 5、需要...
基于stm32的智能小车(远程控制、避障、循迹)
kk1kk2kk3kk4的博客
12-01 1889
学完stm32，总是想做点东西“大显身手”一下，智能小车就成了首选项目，其核心只是就是PWM输出，I/O口引脚电平判断。由于我们做的控制功能可以使用2.4G控制，也可以使用蓝牙进行控制，两种传输方式所需购买的模块不同，已在硬件名单中加以区分，接下来就一步步的实现。
基于stm32蓝牙收发数据代码
05-07
基于stm32 通过串口实现蓝牙与手机蓝牙串口通信助手实现向蓝牙发送数据 然后再返回手机
基于STM32的蓝牙遥控小车：手机APP控制小车运动
mbs706的博客
02-26 2064
这里由于电机只有两个，比较少，为了灵活运用普通IO口驱动电机，我使用了GPIO模拟输出PWM的方法，用一个定时器定时10us,并设定参数让IO口在定时中断里面定时翻转，比如100个周期内高电平为50个低电平为50个，那么就得到一个周期为1ms，脉宽为50%的PWM。4、电机驱动电路，这里是用了一个非常便宜的驱动芯片，大约1元一片的DRV8833，搭建一下外围电路就可以工作了，接线端子接入电机就可以正常驱动电机运转。3、蓝牙控制部分代码，这里把接收到手机发过来的摇杆数据，处理成每个电机的速度、前后。
STM32C8T6控制智能小车代码
szq0909的博客
07-04 2792
一个STM32控制小车的代码，包含小车的前进后退转弯调速蓝牙通信等
STM32蓝牙控制循迹避障小车源代码——1.电机驱动，变速
www_haha__的博客
12-16 1万+
STM32蓝牙控制循迹避障小车源代码——1.电机驱动，变速 注意-所需模块： 主控：STM32F103C8T6（F1系列板子均可以） 驱动芯片：L298N（1个） 接线：L298N: A6–IN1 A7–IN2 B0–IN3 B1–IN4 ENA:5V ENB:5V 代码 所有的代码都是直接从工程里面复制的，实测是没有问题的。 1.电机控制：moter.c 参考文章： 基于STM32F103C8T6的循迹避障小车完整制作过程 这篇文章详细讲解了PWM调速原理以及定时器通道的选择 我这里再简单总结一下
基于STM32的智能小车寻迹避障系统硬件设计.pdf
09-04
智能小车寻迹避障系统采用STM32F103C8T6芯片做为控 制器。系统包括轨迹识别模块电路、障碍物识别模块电路、 直流电机驱动模块电路、单片机最小系统等电路。各个模块 采集到的信息输送至STM32控制器，由控制器负责处理、分 析采集到的数据，得到结果后，通过控制L298N电机驱动模 块控制电机输出转速，改变车辆移动状态。
简单的STM32蓝牙遥控小车完整项目及资料分享，超全
热门推荐
wqeqwq213e的博客
11-10 5万+
简单的蓝牙小车，目前就只是手机控制小车前进转弯后退刹车这种功能，自己还在扩展··· 1：材料 车体、4个轮子、4个减速马达这一套，淘宝搜智能小车关键字就有卖； 12V锂电池x1； 电源开关x1（有个开关方便点）； STM32F103C8T6最小系统单片机x1； 给单片机下载程序的JLINK x1； TB6612FNG直流电机驱动模块x2（一块能控制2个马达，我是四驱，所以要两块）； HC-08蓝牙4.0模块x1（我是苹果手机，只支持4.0，安卓手机没用过，应该HC-05蓝牙2.0也.
实战小项目——基于STM32的蓝牙小车
qq_53022278的博客
10-12 1万+
目录 前言 一、所需材料 二、连接电路 三、具体代码 总结 前言 我相信看到这篇文章的人，一定对单片机有所了解。我猜测许多人都是看视频学习的吧，但是学习效率不高，总是处在一种似懂非懂的状态。我当初也是这种状态，后面意识到学单片机要多做项目，这样印象更加深刻，做项目也能检验自己的学习状态。下面介绍蓝牙遥控小车的制作，这个也是当初的第一个小项目。这个小项目主要用到了单片机定时器和串口。 一、所需材料 1、一块stm32f103c8t6最小系统开发板 2、一块HC05蓝牙...
基于STM32的最简易蓝牙遥控小车
weixin_43469377的博客
02-01 8464
基于STM32的蓝牙遥控小车，基于HAL库编写代码，具有移动功能，读者可自行添加其他扩展功能。按下状态的对应关系：2前进，4左转，5停止，6右转，8后退，松开状态都是5，都选择16进制。首先按照小车的图纸把小车的机械部分装好。做这个小车的成本在200元左右，包括焊接设备，杜邦线等。
智能小车STM32——蓝牙循迹
m0_63076898的博客
10-18 1715
蓝牙切换功能：智能小车内置了蓝牙模块，可以通过手机或其他蓝牙设备与之连接。用户可以通过手机发送指令控制小车的运动方向,实现远程控制。循迹功能：智能小车配备了红外线传感器，可以实现循迹功能。通过检测地面上的黑线或白线，小车能够自动沿着线路行驶，实现自动导航功能。1.硬件准备小车底盘一个（两驱），5号4节电池盒一个，STM32f103c8t6最小系统板，红外光电反射传感器两个，ST-LINK下载器，HC-05蓝牙模块、CH340模块、L298N电机驱动模块，焊接设备、一些杜邦线、也可以再准备一个面包板。
基于stm32的智能小车
2301_77164542的博客
07-05 9487
语音模块硬件接线 A25 -- PA15 （跟随） A26 -- PA13 （避障） A27 -- PA14 （循迹）电机接线：B-1A -- PB0 B-1B -- PB1 A-1A -- PB2 A-1B -- PB10。语音模块控制：多种语音改变多种引脚的电平，通过语音控制实现以上多种功能的切换。跟随功能：通过超声波测出小车和跟随物的距离决定移动方向。硬件接线 SCL -- PB6 SDA -- PB7。-- PB3 循迹模块（右） -- PB4。-- PB5 跟随模块（右） -- PB6。
基于stm32的智能小车(遥控控制、避障、循迹)
07-20
stm32f103系列单片机控制智能小车，具有三种控制方式，遥控控制、避障、循迹(内含三个工程，分别对应三种控制方式) 详细介绍：https://blog.csdn.net/m0_59113542/article/details/123811441?spm=1001.2014.3001.5501
基于STM32的智能四驱小车循迹，避障，红外遥控
01-19
1.时钟源 外部时钟 2.GPIO (实验：点亮LED灯，获取引脚的电平高低，将对应引脚置高置低)。 3.PWM-脉宽调制 主要是调节占空比(在小车中用来实现小车的加减速)。 4.TIMX定时器 5.红外遥控 主要运用了EXTI(外部中断/事件控制器)，系统延时（系统滴答定时器SysTick）。 6.超声波避障 了解了超声波工作的原理，主要运用了TIM2定时器(用来定时测距)，GPIO口。 7.红外探测 通过对障碍物和光的感应来返回电平的状态，从而达到避障和巡线效果。 8.测速码盘 (通过检测码盘上的凹槽数来获取脉冲数，通过计算公式得到小车当前速度) TIM3定时器（定时测速）。 9.PID算法 为了使小车的速度更快的达到目标值，获取更稳定的速度。 10．系统的使用 我们在小车内加入系统，对小车的数据获取，状态实现任务化，使小车内的运作更加有序。我们主要使用μC/OS-II系统内核来实现系统。在实现过程中，我们了解了系统的任务调度以及任务运行和处理器之间的关系(多任务同时运行)。 μC/OS-II内核中的任务控制块，任务状态，以及多任务和任务的优先级类似操作系统中的进程操作。 11.任务间的通信 主要用到信号量(主要就是PV操作 P操作：占用资源。V操作：释放资源)；邮箱(邮箱可以使一个任务或者中断服务子程序向另一个任务发送指针型的变量，通常该指针指向包含了“消息”特定的数据结构)。
基于stm32f103的蓝牙遥控小车
09-09
自己的小车能够完美运行，使用手机蓝牙进行控制，对所有原本存在的问题进行了修改，能够完成前进、后退、左转、右转、原地左转、原地右转等功能，集成在电机控制文件，能够在此基础上加上电机的PWM控制和更多地功能。
基于STM32智能循迹避障小车(设计报告).pdf
07-01
基于STM32智能循迹避障小车(设计报告).pdf基于STM32智能循迹避障小车(设计报告).pdf基于STM32智能循迹避障小车(设计报告).pdf基于STM32智能循迹避障小车(设计报告).pdf基于STM32智能循迹避障小车(设计报告).pdf基于...
STM32 float浮点数转换成四个字节
最新发布
m0_73640344的博客
04-25 462
联合体的大小由其最大的成员决定，并且这个大小会按照需要满足最大成员对齐要求的方式来进行调整。但是，如果你先将这些浮点数复制到联合体中，由于联合体确保了四字节对齐，你就可以安全地对这些数进行操作，不会遇到总线错误。因此，编译器会确保联合体的对齐满足其内部最严格对齐要求的成员，这通常是最大的数据类型成员。使用联合体是一种解决方案，因为联合体内存的对齐会确保即使是从数组中取出的浮点数数据，也能满足FPU的对齐要求。这意味着，如果你修改了联合体中的一个成员，就可能改变另一个成员的值，因为它们共享相同的内存位置。
STM32 HAL库F103系列之DAC实验（一）
2302_79878697的博客
04-23 641
* DAC 寄存器基地址 *//* DAC 工作状态 *//* DAC 锁定对象 *//* 通道 1 的 DMA 处理句柄指针 *//* 通道 2 的 DMA 处理句柄指针 *//* DAC 错误代码 *//* DAC 触发源的选择 *//* 启用或者禁用 DAC 通道输出缓冲区 */
STM32使用HAL库解码433遥控芯片EV1527
qq_39649731的博客
04-19 431
STM32解码433遥控器
STM32蓝牙遥控小车
05-19
您好，关于实现STM32蓝牙遥控小车的方法，可以参考以下步骤： 1. 准备材料：STM32开发板、蓝牙模块、电机驱动模块、直流电机、小车底盘、电池等。 2. 连接电路：将蓝牙模块与STM32开发板连接，将电机驱动模块与STM32开发板连接，将直流电机与电机驱动模块连接，将电池与STM32开发板和电机驱动模块连接。 3. 编写程序：使用Keil等开发工具编写程序，实现蓝牙模块接收手机发送的指令，并通过电机驱动模块控制小车运动。 4. 调试程序：将程序下载到STM32开发板中，进行调试，确保小车能够正常运动。 5. 连接手机：在手机上安装蓝牙遥控APP，连接蓝牙模块，发送指令，控制小车运动。 希望以上步骤对您有所帮助，祝您成功完成STM32蓝牙遥控小车的制作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值