草庐IT

简单的STM32蓝牙遥控小车完整项目及资料分享，超全

努力上进的小白白 2023-04-22 原文

自学新手的第一个项目，做的时也在论坛查了许多大佬的文章，但还是有许多疑问，我就从一个小白的角度出发来和大家分享，应该对许多自学不久的萌新来说比较友好易懂。欢迎大家交流，大佬轻喷~~

简单的蓝牙小车，目前就只是手机控制小车前进转弯后退刹车这种功能，自己还在扩展···

PS:软件及接线图、原理图、芯片手册等资料都打包在文章末尾的下载链接中！！！

做好了的样子↓，遥控运行的视频：基于stm32的简单蓝牙小车_哔哩哔哩_bilibili真真正正的小白，刚接触这这方面自学不久，分享下第一个简单项目，虽简单但还是很有成就感的，自己找资料前前后后弄了三天吧。大佬勿喷，可以交流分享经验，分享项目。硬件部分：12v点电池DC-DC12V转3.3V模块TB6612模块x2stm32f103c8t6最小单片机系统hc-08蓝牙模块淘宝买的小车本体连带马达的具体代码和硬件资料还有详细的接线图可以私聊我https://www.bilibili.com/video/BV1Hg411K7md/

1：材料

车体、4个轮子、4个减速马达这一套，淘宝搜智能小车关键字就有卖；

12V锂电池x1；

电源开关x1（有个开关方便点）；

STM32F103C8T6最小系统单片机x1；

JLINK烧写器 x1；

TB6612FNG直流电机驱动模块x2（一块能控制2个马达，我做的是四驱，所以要两块）；

HC-08蓝牙4.0模块x1（我是苹果手机，只支持4.0，安卓手机没用过，应该HC-05蓝牙2.0也能  用，看自己情况定，代码没区别通用）；

手机x1（苹果蓝牙控制app：HackerRemote 要6元买；安卓这类带按键控制界面的蓝牙app比较多，自己找下吧~）

DC-DC 12V转3.3V模块x1；

母-母、公-母、公-公杜邦线若干（我自己接的话消耗量按左到右顺序递减）；

作业工具（烙铁重要，胶带双面胶等按自己需要买吧）~~；

下面放上淘宝购物清单（防止被以为打广告，店名不放）↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓

2.接线图及单片机原理图（下面2图+芯片的数据手册看就很清楚）

！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

PS:下图TB6612模块的STBY脚接线忘记画了，STBY是使能/失能模块工作，可以直接3.3V或者接IO口置高电平就能工作，我自己是直接接的3.3V。“3.TB6612电机驱动模块介绍”的图中有标注。

重点，千万别漏了，好多人漏看了这一句话，车不动，也怪我接线图里忘记画了

！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

 

 PS:软件及接线图、原理图、芯片手册等资料都打包在文章末尾的下载链接中！！！

 3.TB6612电机驱动模块介绍

 真值表：

 四个电机，需要用到2个模块，另一个同理~~

4.HC-08蓝牙4.0模块介绍

 这个模块就不多说了，买到手直接用，不需要做配置，我们只需接中间四个引脚（参考接线图）。有兴趣的自行百度或者看我附件里的手册资料。

 PS:软件及接线图、原理图、芯片手册等资料都打包在文章末尾的下载链接中！！！

5.部分代码（完整代码下载文末附件）

1.main.c部分，比较简单

int main(void)
{
	TB6612_FR_Init();      //初始化TB6612模块1和模块2
	
	MotorAllOFF();         //单片机上电默认先把4个电机关闭
	
	USART3_Config();       //初始化蓝牙模块的串口
	
	while(1)
	{
 		RUN_Prg();   //小车蓝牙控制功能
	}
}

2.串口通讯部分

bsp_usart.c

#include "bsp_usart.h"

static void USART3_NVIC_Config(void)
{
	NVIC_InitTypeDef NVIC_InitStructure;
	
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	
	NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_Init(&NVIC_InitStructure);
}

void USART3_Config(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);   //使能GPIO时钟
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);	//使能USART3时钟
	
	/*TX_GPIO*/
	GPIO_InitStructure.GPIO_Pin = USART3_GPIO_TX_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(USART3_GPIO_TX_PORT, &GPIO_InitStructure);
	
	/*RX_GPIO*/
	GPIO_InitStructure.GPIO_Pin = USART3_GPIO_RX_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(USART3_GPIO_RX_PORT, &GPIO_InitStructure);
	
	/*USART3*/
	USART_InitStructure.USART_BaudRate = 9600;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	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(USART3, &USART_InitStructure);

  USART3_NVIC_Config();  
	USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);   //使能串口接收终断
	USART_Cmd(USART3, ENABLE);  //使能串口
}

bsp_usart.h

#ifndef __BSP_USART_H
#define __BSP_USART_H

#include "stm32f10x.h"

/*TX的GPIO端口定义*/
#define USART3_GPIO_TX_PIN					 GPIO_Pin_10
#define USART3_GPIO_TX_PORT					 GPIOB
#define USART3_GPIO_TX_CLK					 RCC_APB2Periph_GPIOB

/*RX的GPIO端口定义*/
#define USART3_GPIO_RX_PIN					 GPIO_Pin_11
#define USART3_GPIO_RX_PORT					 GPIOB
#define USART3_GPIO_RX_CLK					 RCC_APB2Periph_GPIOB

/*USART3定义*/
#define DEBUG_USARTx_CLK						 RCC_APB1Periph_USART3


void USART3_Config(void);
void USART3_Prg(void);


#endif /*__BSP_USART_H*/

3.TB6612电机驱动模块部分

bsp_tb6612.c

#include "bsp_tb6612.h"

/*TB6612模块1，驱动前轮  F*/
void TB6612_F_GPIO_Config(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(TB6612_F_GPIO_AIN1_CLK | TB6612_F_GPIO_AIN2_CLK |              \
												 TB6612_F_GPIO_BIN1_CLK | TB6612_F_GPIO_BIN2_CLK , ENABLE);
	
	GPIO_InitStructure.GPIO_Pin = TB6612_F_GPIO_AIN1_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	
	GPIO_Init(TB6612_F_GPIO_AIN1_PORT, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = TB6612_F_GPIO_AIN2_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	
	GPIO_Init(TB6612_F_GPIO_AIN2_PORT, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin = TB6612_F_GPIO_BIN1_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	
	GPIO_Init(TB6612_F_GPIO_BIN1_PORT, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin = TB6612_F_GPIO_BIN2_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	
	GPIO_Init(TB6612_F_GPIO_BIN2_PORT, &GPIO_InitStructure);	
}

void TB6612_F_PWM_GPIO_Config(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(TB6612_F_GPIO_PWMA_CH1_CLK, ENABLE);
	GPIO_InitStructure.GPIO_Pin = TB6612_F_GPIO_PWMA_CH1_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	
	GPIO_Init(TB6612_F_GPIO_PWMA_CH1_PORT,&GPIO_InitStructure);
	
	RCC_APB2PeriphClockCmd(TB6612_F_GPIO_PWMB_CH2_CLK, ENABLE);
	GPIO_InitStructure.GPIO_Pin = TB6612_F_GPIO_PWMB_CH2_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	
	GPIO_Init(TB6612_F_GPIO_PWMB_CH2_PORT,&GPIO_InitStructure);
}

/*TB6612模块2，驱动后轮  R*/
void TB6612_R_GPIO_Config(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(TB6612_R_GPIO_AIN1_CLK | TB6612_R_GPIO_AIN2_CLK |              \
												 TB6612_R_GPIO_BIN1_CLK | TB6612_R_GPIO_BIN2_CLK , ENABLE);
	
	GPIO_InitStructure.GPIO_Pin = TB6612_R_GPIO_AIN1_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(TB6612_R_GPIO_AIN1_PORT, &GPIO_InitStructure);
	
	GPIO_InitStructure.GPIO_Pin = TB6612_R_GPIO_AIN2_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(TB6612_R_GPIO_AIN2_PORT, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin = TB6612_R_GPIO_BIN1_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(TB6612_R_GPIO_BIN1_PORT, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin = TB6612_R_GPIO_BIN2_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(TB6612_R_GPIO_BIN2_PORT, &GPIO_InitStructure);
}

void TB6612_R_PWM_GPIO_Config(void)
{
	GPIO_InitTypeDef GPIO_InitStructure;
	
	RCC_APB2PeriphClockCmd(TB6612_R_GPIO_PWMA_CH3_CLK, ENABLE);	
	GPIO_InitStructure.GPIO_Pin = TB6612_R_GPIO_PWMA_CH3_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	
	GPIO_Init(TB6612_R_GPIO_PWMA_CH3_PORT,&GPIO_InitStructure);

	RCC_APB2PeriphClockCmd(TB6612_R_GPIO_PWMB_CH4_CLK, ENABLE);
	GPIO_InitStructure.GPIO_Pin = TB6612_R_GPIO_PWMB_CH4_PIN;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;	
	GPIO_Init(TB6612_R_GPIO_PWMB_CH4_PORT,&GPIO_InitStructure);
}

static void ADVANCE_TIM1_Mode_Config(void)
{
	TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;
	TIM_OCInitTypeDef TIM_OCInitStructure;
	
	RCC_APB2PeriphClockCmd(ADVANCE_TIM_CLK , ENABLE);
	
	TIM_TimeBaseInitStructure.TIM_Prescaler = (72-1);
	TIM_TimeBaseInitStructure.TIM_Period = (100-1);
	TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;
	TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
	TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
	TIM_TimeBaseInit(ADVANCE_TIM, &TIM_TimeBaseInitStructure);
	
	TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1; 
	TIM_OCInitStructure.TIM_OCPolarity = TIM_OCPolarity_High;
	TIM_OCInitStructure.TIM_OCNPolarity = TIM_OCNPolarity_High;
	TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
	TIM_OCInitStructure.TIM_OutputNState = TIM_OutputNState_Enable;
	TIM_OCInitStructure.TIM_OCIdleState = TIM_OCIdleState_Set;
	TIM_OCInitStructure.TIM_OCNIdleState = TIM_OCNIdleState_Reset;
	
	TIM_OCInitStructure.TIM_Pulse = 0;
	TIM_OC1Init(ADVANCE_TIM, &TIM_OCInitStructure);
	TIM_OC1PreloadConfig(ADVANCE_TIM,TIM_OCPreload_Enable);
	
	TIM_OCInitStructure.TIM_Pulse = 0;
	TIM_OC2Init(ADVANCE_TIM, &TIM_OCInitStructure);
	TIM_OC2PreloadConfig(ADVANCE_TIM,TIM_OCPreload_Enable);
	
	TIM_OCInitStructure.TIM_Pulse = 0;
	TIM_OC3Init(ADVANCE_TIM, &TIM_OCInitStructure);
	TIM_OC3PreloadConfig(ADVANCE_TIM,TIM_OCPreload_Enable);
	
	TIM_OCInitStructure.TIM_Pulse = 0;
	TIM_OC4Init(ADVANCE_TIM, &TIM_OCInitStructure);
	TIM_OC4PreloadConfig(ADVANCE_TIM,TIM_OCPreload_Enable);
	
	TIM_Cmd(ADVANCE_TIM, ENABLE);
}

//void TB6612_F_Init(void)    //控制前面2轮的电机驱动模块初始化
//{
//	TB6612_F_GPIO_Config();
//	TB6612_F_PWM_GPIO_Config();
//	ADVANCE_TIM1_Mode_Config();
//}

//void TB6612_R_Init(void)    //控制后面2轮的电机驱动模块初始化
//{
//	TB6612_R_GPIO_Config();
//	TB6612_R_PWM_GPIO_Config();
//	ADVANCE_TIM1_Mode_Config();
//}

void TB6612_FR_Init(void)		//控制前和后2轮的电机驱动模块初始化
{
	TB6612_F_GPIO_Config();
	TB6612_F_PWM_GPIO_Config();
	TB6612_R_GPIO_Config();
	TB6612_R_PWM_GPIO_Config();
	ADVANCE_TIM1_Mode_Config();
}

bsp_tb6612.h

#ifndef __BSP_TB6612_H
#define __BSP_TB6612_H

#include "stm32f10x.h"

/*TB6612模块1*/
/*定义TB6612模块1(驱动前轮(_F))的AIN1、AIN2、BIN1、BIN2的GPIO端口*/
#define TB6612_F_GPIO_AIN1_PIN  			GPIO_Pin_12
#define TB6612_F_GPIO_AIN1_PORT  			GPIOB
#define TB6612_F_GPIO_AIN1_CLK    		RCC_APB2Periph_GPIOB 

#define TB6612_F_GPIO_AIN2_PIN  			GPIO_Pin_13
#define TB6612_F_GPIO_AIN2_PORT   		GPIOB
#define TB6612_F_GPIO_AIN2_CLK    		RCC_APB2Periph_GPIOB

#define TB6612_F_GPIO_BIN1_PIN  			GPIO_Pin_14
#define TB6612_F_GPIO_BIN1_PORT   		GPIOB
#define TB6612_F_GPIO_BIN1_CLK    		RCC_APB2Periph_GPIOB 

#define TB6612_F_GPIO_BIN2_PIN  			GPIO_Pin_15
#define TB6612_F_GPIO_BIN2_PORT   		GPIOB
#define TB6612_F_GPIO_BIN2_CLK    		RCC_APB2Periph_GPIOB

/*定义TB6612模块1(驱动前轮(_F))的PWMA、PWMB的GPIO端口*/
#define TB6612_F_GPIO_PWMA_CH1_PIN    GPIO_Pin_8
#define TB6612_F_GPIO_PWMA_CH1_PORT 	GPIOA
#define TB6612_F_GPIO_PWMA_CH1_CLK  	RCC_APB2Periph_GPIOA

#define TB6612_F_GPIO_PWMB_CH2_PIN    GPIO_Pin_9
#define TB6612_F_GPIO_PWMB_CH2_PORT 	GPIOA
#define TB6612_F_GPIO_PWMB_CH2_CLK  	RCC_APB2Periph_GPIOA

/*TB6612模块2*/
/*定义TB6612模块2(驱动后轮(_R))的AIN1、AIN2、BIN1、BIN2的GPIO端口*/
#define TB6612_R_GPIO_AIN1_PIN  			GPIO_Pin_6
#define TB6612_R_GPIO_AIN1_PORT  			GPIOB
#define TB6612_R_GPIO_AIN1_CLK    		RCC_APB2Periph_GPIOB 

#define TB6612_R_GPIO_AIN2_PIN  			GPIO_Pin_7
#define TB6612_R_GPIO_AIN2_PORT   		GPIOB
#define TB6612_R_GPIO_AIN2_CLK    		RCC_APB2Periph_GPIOB

#define TB6612_R_GPIO_BIN1_PIN  			GPIO_Pin_8
#define TB6612_R_GPIO_BIN1_PORT   		GPIOB
#define TB6612_R_GPIO_BIN1_CLK    		RCC_APB2Periph_GPIOB 

#define TB6612_R_GPIO_BIN2_PIN  			GPIO_Pin_9
#define TB6612_R_GPIO_BIN2_PORT   		GPIOB
#define TB6612_R_GPIO_BIN2_CLK    		RCC_APB2Periph_GPIOB

/*定义TB6612模块2(驱动后轮(_R))的PWMA、PWMB的GPIO端口*/
#define TB6612_R_GPIO_PWMA_CH3_PIN    GPIO_Pin_10
#define TB6612_R_GPIO_PWMA_CH3_PORT 	GPIOA
#define TB6612_R_GPIO_PWMA_CH3_CLK  	RCC_APB2Periph_GPIOA

#define TB6612_R_GPIO_PWMB_CH4_PIN    GPIO_Pin_11
#define TB6612_R_GPIO_PWMB_CH4_PORT 	GPIOA
#define TB6612_R_GPIO_PWMB_CH4_CLK  	RCC_APB2Periph_GPIOA



/*高级定时器TIM1参数定义*/ 
#define ADVANCE_TIM                 TIM1
#define ADVANCE_TIM_CLK             RCC_APB2Periph_TIM1


void TB6612_F_GPIO_Config(void);
void TB6612_F_PWM_GPIO_Config(void);
void TB6612_R_GPIO_Config(void);
void TB6612_R_PWM_GPIO_Config(void);
//void TB6612_F_Init(void);
//void TB6612_R_Init(void);
void TB6612_FR_Init(void);


#endif /*BSP_TB6612_H*/

4.马达动作部分

bsp_motor.c

#include "bsp_motor.h"

//马达控制函数，第一个参数为选定哪个马达，第二个参数是选定马达状态
void MotorCtrl(uint32_t motornum,uint32_t state)
{
	if(motornum == LEFT_FRONT)   //左前马达1
	{
		switch(state)
		{
			case OFF:
				F_AIN1(LOW);
				F_AIN2(LOW);
				break;
			case FORWARD:
				F_AIN1(HIGH);
				F_AIN2(LOW);
				break;			
			case REVERSE:
				F_AIN1(LOW);
				F_AIN2(HIGH);							
				break;
			case BRAKE:
				F_AIN1(HIGH);
				F_AIN2(HIGH);
				break;
			default:
				break;
		}
	}
	else if(motornum == RIGHT_FRONT)  //右前马达2
	{
		switch(state)
		{
			case OFF:
				F_BIN1(LOW);
				F_BIN2(LOW);
				break;
			case FORWARD:
				F_BIN1(HIGH);
				F_BIN2(LOW);
				break;			
			case REVERSE:
				F_BIN1(LOW);
				F_BIN2(HIGH);
				break;
			case BRAKE:
				F_BIN1(HIGH);
				F_BIN2(HIGH);
				break;
			default:
				break;
		}
	}
	else if(motornum == LEFT_REAR)   //左后马达3
	{
		switch(state)
		{
			case OFF:
				R_AIN1(LOW);
				R_AIN2(LOW);
				break;
			case FORWARD:
				R_AIN1(HIGH);
				R_AIN2(LOW);
				break;			
			case REVERSE:
				R_AIN1(LOW);
				R_AIN2(HIGH);							
				break;
			case BRAKE:
				R_AIN1(HIGH);
				R_AIN2(HIGH);
				break;
			default:
				break;
		}
	}
	else if(motornum == RIGHT_REAR)    //右后马达4
	{
		switch(state)
		{
			case OFF:
				R_BIN1(LOW);
				R_BIN2(LOW);
				break;
			case FORWARD:
				R_BIN1(HIGH);
				R_BIN2(LOW);
				break;			
			case REVERSE:
				R_BIN1(LOW);
				R_BIN2(HIGH);
				break;
			case BRAKE:
				R_BIN1(HIGH);
				R_BIN2(HIGH);
				break;
			default:
				break;
		}
	}
}

/*马达全部关闭函数*/
void MotorAllOFF(void)
{
	MotorCtrl(LEFT_FRONT,OFF);
	MotorCtrl(LEFT_REAR,OFF);
	MotorCtrl(RIGHT_FRONT,OFF);
	MotorCtrl(RIGHT_REAR,OFF);
}

bsp_motor.h

#ifndef __BSP_MOTOR_H
#define __BSP_MOTOR_H

#include "bsp_tb6612.h"

/*H桥两端电平高低控制*/
#define HIGH     	 1
#define LOW   		 0

/*TB6612模块1，驱动前轮  F*/
/*AIN1*/
#define F_AIN1(a)				if(a) GPIO_SetBits(TB6612_F_GPIO_AIN1_PORT, TB6612_F_GPIO_AIN1_PIN); \
												else  GPIO_ResetBits(TB6612_F_GPIO_AIN1_PORT, TB6612_F_GPIO_AIN1_PIN)
/*AIN2*/
#define F_AIN2(a)				if(a)	GPIO_SetBits(TB6612_F_GPIO_AIN2_PORT, TB6612_F_GPIO_AIN2_PIN); \
												else  GPIO_ResetBits(TB6612_F_GPIO_AIN2_PORT, TB6612_F_GPIO_AIN2_PIN)
/*BIN1*/
#define F_BIN1(a)				if(a) GPIO_SetBits(TB6612_F_GPIO_BIN1_PORT, TB6612_F_GPIO_BIN1_PIN); \
												else  GPIO_ResetBits(TB6612_F_GPIO_BIN1_PORT, TB6612_F_GPIO_BIN1_PIN)
/*BIN2*/
#define F_BIN2(a)				if(a) GPIO_SetBits(TB6612_F_GPIO_BIN2_PORT, TB6612_F_GPIO_BIN2_PIN); \
											  else  GPIO_ResetBits(TB6612_F_GPIO_BIN2_PORT, TB6612_F_GPIO_BIN2_PIN)

/*TB6612模块2，驱动后轮  R*/											
/*AIN1*/
#define R_AIN1(a)				if(a) GPIO_SetBits(TB6612_R_GPIO_AIN1_PORT, TB6612_R_GPIO_AIN1_PIN); \
												else  GPIO_ResetBits(TB6612_R_GPIO_AIN1_PORT, TB6612_R_GPIO_AIN1_PIN)
/*AIN2*/
#define R_AIN2(a)				if(a)	GPIO_SetBits(TB6612_R_GPIO_AIN2_PORT, TB6612_R_GPIO_AIN2_PIN); \
												else  GPIO_ResetBits(TB6612_R_GPIO_AIN2_PORT, TB6612_R_GPIO_AIN2_PIN)
/*BIN1*/
#define R_BIN1(a)				if(a) GPIO_SetBits(TB6612_R_GPIO_BIN1_PORT, TB6612_R_GPIO_BIN1_PIN); \
												else  GPIO_ResetBits(TB6612_R_GPIO_BIN1_PORT, TB6612_R_GPIO_BIN1_PIN)
/*BIN2*/
#define R_BIN2(a)				if(a) GPIO_SetBits(TB6612_R_GPIO_BIN2_PORT, TB6612_R_GPIO_BIN2_PIN); \
											  else  GPIO_ResetBits(TB6612_R_GPIO_BIN2_PORT, TB6612_R_GPIO_BIN2_PIN)

/*MotorCtrl(uint32_t motornum,uint32_t state)函数的参数宏定义*/												
#define LEFT_FRONT  1      //马达1（AIN、左前轮）
#define RIGHT_FRONT 2      //马达2（BIN、右前轮）	
#define LEFT_REAR   3      //马达3（AIN、左后轮）
#define RIGHT_REAR  4      //马达4（BIN、右后轮）															

#define OFF					0			 //停止转动
#define FORWARD 		1      //正转
#define REVERSE     2			 //反转
#define BRAKE				3			 //制动


void MotorCtrl(uint32_t motornum,uint32_t state);
void MotorAllOFF(void);

#endif /*__BSP_MOTOR_H*/

5.接收中断部分

stm32f10x_it.h

#include "bsp_usart.h"

uint8_t rx_data;
uint32_t rx_end;

void USART3_IRQHandler(void)
{	
	if(USART_GetITStatus(USART3,USART_IT_RXNE) != RESET)
	{
		rx_data = USART_ReceiveData(USART3);   //接收到的数据放入rx_data
		rx_end = 1;
	}
	USART_ClearITPendingBit(USART3,USART_IT_RXNE);   //清除中断待处理位
}

6.最后是遥控控制小车部分

car_ctrl.c

#include "car_ctrl.h"
#include "bsp_usart.h"
#include "bsp_motor.h"

extern uint8_t rx_end;
extern uint8_t rx_data;

void RUN_Prg(void)
{
	if(rx_end)
	{
		rx_end = 0;
		if(rx_data == 'U')  			 //前进     (左前、左后轮反转， 右前、右后轮子正转)
		{
			MotorCtrl(LEFT_FRONT,REVERSE);
			MotorCtrl(LEFT_REAR,REVERSE);
			MotorCtrl(RIGHT_FRONT,FORWARD);
			MotorCtrl(RIGHT_REAR,FORWARD);			
		}
		else if(rx_data == 'L')    //左转  (左前、左后轮正转， 右前、右后轮子正转)
		{
			MotorCtrl(LEFT_FRONT,FORWARD);
			MotorCtrl(LEFT_REAR,FORWARD);
			MotorCtrl(RIGHT_FRONT,FORWARD);
			MotorCtrl(RIGHT_REAR,FORWARD);
		}		
		else if(rx_data == 'R')    //右转  (左前、左后轮反转， 右前、右后轮子反转)
		{
			MotorCtrl(LEFT_FRONT,REVERSE);
			MotorCtrl(LEFT_REAR,REVERSE);
			MotorCtrl(RIGHT_FRONT,REVERSE);
			MotorCtrl(RIGHT_REAR,REVERSE);			
		}
		else if(rx_data == 'D')    //后退  (左前、左后轮正转， 右前、右后轮子反转)
		{
			MotorCtrl(LEFT_FRONT,FORWARD);
			MotorCtrl(LEFT_REAR,FORWARD);
			MotorCtrl(RIGHT_FRONT,REVERSE);
			MotorCtrl(RIGHT_REAR,REVERSE);		
		}
		else if(rx_data == 'B')		 //刹车
		{
			MotorCtrl(LEFT_FRONT,BRAKE);
			MotorCtrl(LEFT_REAR,BRAKE);
			MotorCtrl(RIGHT_FRONT,BRAKE);
			MotorCtrl(RIGHT_REAR,BRAKE);			
		}	
		else if(rx_data == 'u'|'l'|'r'|'d'|'S'|'s'|'b')//前进|左转|右转|后退|关闭电机按下/松掉|刹车键松掉后都关闭电机
		{
			MotorCtrl(LEFT_FRONT,OFF);
			MotorCtrl(LEFT_REAR,OFF);
			MotorCtrl(RIGHT_FRONT,OFF);
			MotorCtrl(RIGHT_REAR,OFF);			
		}
	}
}

PS:软件及接线图、原理图、芯片手册等资料都打包在文章末尾的下载链接中！！！ 

6.APP通信协议介绍

软件说明↓↓↓↓↓↓↓红框内容就是很简单的通信协议了

IOS端APP：HackerRemote

 刷新列表，找到你蓝牙模块的名字，点进去如下图

把Service UUID、TX UUID、RX UUID改成下图框里的默认值，点击连接就好了

连上之后蓝牙模块蓝灯长亮，app界面如下图。好了，可以愉快的遥控小车了~~~

7.完整程序和资源下载地址：

链接：https://pan.baidu.com/s/1FkaoSZ0fNEJ3TbaNO1fp5A 
提取码：wsmx

※好多朋友私信我说工程报错，下图这2个文件删了就行

（本来是准备加一个超声波模块的，后面没搞，文件忘记删了）

8.有问题欢迎评论留言交流，每天都会看一下帖子及时解答~ 

9.分享一个OLED+天气显示的小电视 

                                   

视频地址：OLED+ESP8266 时钟天气显示_哔哩哔哩_bilibili

教学视频地址：OELD+ESP8266 时钟天气显示小电视 制作教程!!(超细致)(太极创客开源项目)_哔哩哔哩_bilibili

外观结构改版已在立创开源社区开源：https://oshwhub.com/yz961114/oled-esp8266-tian-qi-shi-zhong-xian-shi 

10.分享一个11万转速的暴力小风扇    

                         

视频地址：11w转暴力小风扇_哔哩哔哩_bilibili

接线图及物料清单地址：11w转暴力小风扇 超详细购买清单说明以及接线图_哔哩哔哩_bilibili

STM32GPIOxff6612stm32单片机arm

有关简单的STM32蓝牙遥控小车完整项目及资料分享，超全的更多相关文章

  1. ruby - 简单获取法拉第超时 - 2

    有没有办法在这个简单的get方法中添加超时选项？我正在使用法拉第3.3。Faraday.get(url)四处寻找，我只能先发起连接后应用超时选项，然后应用超时选项。或者有什么简单的方法？这就是我现在正在做的:conn=Faraday.newresponse=conn.getdo|req|req.urlurlreq.options.timeout=2#2secondsend 最佳答案 试试这个:conn=Faraday.newdo|conn|conn.options.timeout=20endresponse=conn.get(url

  2. ruby - 用 Ruby 编写一个简单的网络服务器 - 2

    我想在Ruby中创建一个用于开发目的的极其简单的Web服务器(不，不想使用现成的解决方案)。代码如下:#!/usr/bin/rubyrequire'socket'server=TCPServer.new('127.0.0.1',8080)whileconnection=server.acceptheaders=[]length=0whileline=connection.getsheaders想法是从命令行运行这个脚本，提供另一个脚本，它将在其标准输入上获取请求，并在其标准输出上返回完整的响应。到目前为止一切顺利，但事实证明这真的很脆弱，因为它在第二个请求上中断并出现错误:/usr/b

  3. ruby-on-rails - 简单的 Ruby on Rails 问题——如何将评论附加到用户和文章？ - 2

    我意识到这可能是一个非常基本的问题，但我现在已经花了几天时间回过头来解决这个问题，但出于某种原因，Google就是没有帮助我。(我认为部分问题在于我是一个初学者，我不知道该问什么......)我也看过O'Reilly的RubyCookbook和RailsAPI，但我仍然停留在这个问题上.我找到了一些关于多态关系的信息，但它似乎不是我需要的(尽管如果我错了请告诉我)。我正在尝试调整MichaelHartl'stutorial创建一个包含用户、文章和评论的博客应用程序(不使用脚手架)。我希望评论既属于用户又属于文章。我的主要问题是:我不知道如何将当前文章的ID放入评论Controller。

  4. ruby - 使用 Ruby 通过 Outlook 发送消息的最简单方法是什么？ - 2

    我的工作要求我为某些测试自动生成电子邮件。我一直在四处寻找，但未能找到可以快速实现的合理解决方案。它需要在outlook而不是其他邮件服务器中，因为我们有一些奇怪的身份验证规则，我们需要保存草稿而不是仅仅发送邮件的选项。显然win32ole可以做到这一点，但我找不到任何相当简单的例子。 最佳答案 假设存储了Outlook凭据并且您设置为自动登录到Outlook，WIN32OLE可以很好地完成此操作:require'win32ole'outlook=WIN32OLE.new('Outlook.Application')message=

  5. postman——集合——执行集合——测试脚本——pm对象简单示例02 - 2

    //1.验证返回状态码是否是200pm.test("Statuscodeis200",function(){pm.response.to.have.status(200);});//2.验证返回body内是否含有某个值pm.test("Bodymatchesstring",function(){pm.expect(pm.response.text()).to.include("string_you_want_to_search");});//3.验证某个返回值是否是100pm.test("Yourtestname",function(){varjsonData=pm.response.json

  6. Qt Designer的简单使用 - 2

    在前面两节的例子中，主界面窗口的尺寸和标签控件显示的矩形区域等，都是用C++代码编写的。窗口和控件的尺寸都是预估的，控件如果多起来，那就不好估计每个控件合适的位置和大小了。用C++代码编写图形界面的问题就是不直观，因此Qt项目开发了专门的可视化图形界面编辑器——QtDesigner（Qt设计师）。通过QtDesigner就可以很方便地创建图形界面文件*.ui，然后将ui文件应用到源代码里面，做到“所见即所得”，大大方便了图形界面的设计。本节就演示一下QtDesigner的简单使用，学习拖拽控件和设置控件属性，并将ui文件应用到Qt程序代码里。使用QtDesigner设计界面在开始菜单中找到「Q

  7. STM32读取串口传感器数据（颗粒物传感器，主动上传） - 2

    文章目录1.开发板选择*用到的资源2.串口通信（个人理解）3.代码分析（注释比较详细）1.主函数2.串口1配置3.串口2配置以及中断函数4.注意问题5.源码链接1.开发板选择我用的是STM32F103RCT6的板子，不过代码大概在F103系列的板子上都可以运行，我试过在野火103的霸道板上也可以，主要看一下串口对应的引脚一不一样就行了，不一样的就更改一下。*用到的资源keil5软件这里用到了两个串口资源，采集数据一个，串口通信一个，板子对应引脚如下：串口1，TX：PA9，RX：PA10串口2，TX：PA2，RX：PA32.串口通信（个人理解）我就从串口采集传感器数据这个过程说一下我自己的理解，

  8. ruby - 使用 Ruby，计算 n x m 数组的每一列中有多少个 true 的简单方法是什么？ - 2

    给定一个nxmbool数组:[[true,true,false],[false,true,true],[false,true,true]]有什么简单的方法可以返回“该列中有多少个true？”结果应该是[1,3,2] 最佳答案 使用转置得到一个数组，其中每个子数组代表一列，然后将每一列映射到其中的true数:arr.transpose.map{|subarr|subarr.count(true)}这是一个带有inject的版本，应该在1.8.6上运行，没有任何依赖:arr.transpose.map{|subarr|subarr.in

  9. ruby - 在 Ruby 中搜索大文件的更简单方法？ - 2

    我正在编写一个简单的日志嗅探器，它将在日志中搜索表明我支持的软件存在问题的特定错误。它允许用户指定日志路径并指定他们想要搜索多少天前。如果用户关闭日志滚动，日志文件有时会变得非常大。目前我正在做以下事情(虽然还没有完成):File.open(@log_file,"r")do|file_handle|file_handle.eachdo|line|ifline.match(/\d+++-\d+-\d+/)etc...line.match显然会查找我们在日志中使用的日期格式，其余逻辑将在下面。但是，有没有更好的方法来搜索没有.each_line的文件？如果没有，我完全同意。我只是想确保我使

  10. ruby - 如何排序不是简单的哈希(哈希的哈希) - 2

    我有一个这样的哈希{55=>{:value=>61,:rating=>-147},89=>{:value=>72,:rating=>-175},78=>{:value=>64,:rating=>-155},84=>{:value=>90,:rating=>-220},95=>{:value=>39,:rating=>-92},46=>{:value=>97,:rating=>-237},52=>{:value=>73,:rating=>-177},64=>{:value=>69,:rating=>-167},86=>{:value=>68,:rating=>-165},53=>{:va

随机推荐