基于STM32的智能小车

已于 2024-07-22 19:45:22 修改
阅读量2.1k 收藏 62
点赞数 25
分类专栏： STM32 文章标签： stm32 单片机
于 2024-04-21 23:44:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78772787/article/details/138036791
版权

目录

一、硬件清单

二、功能实现

三、相关代码

1、让小车动起来

2、串口控制小车方向

3、串口点动控制小车

4、硬件PWM调速控制小车前进

5、硬件PWM调速控制小车左右转

6、循迹小车

7、解决平滑转弯问题

8.跟随/避障小车

9、摇头避障小车

10、小车测速数据通过串口上传到上位机

11、串口控制小车并使用Oled屏显示速度

12、Wi-Fi测速小车并本地Oled显示

13、语音控制小车

一、硬件清单

1、主控STM32F103C8T6

7044c273cf414157af12f711b1a5b1d2.png

2、L9110S电机模块

247c4523120b446c97805a61f8ffae18.png

3、超声波模块

24b67c280b92411e8b9628d8fd15ac3b.png

4、sg90舵机模块

40d9f0ea3c7c4e879a91e92557149437.png

5、oled屏

57856dcfb46f4de6a74dd6110f493d8b.png

6、测速模块

31a2a48f75c44781b831f82d5e0013e2.png

7、红外模块

30b93da795a84b4b88a1a54c83eaca50.png

8、esp8266模块（wifi模块）

337a32904783478489f1cf071f2a9601.png

9、语音模块

97e2defc061f4f07922ca313e2ffefc9.png

10、循迹模块

d5e5f23357e84b1f823427e7b48bb8eb.png

二、功能实现

左右转与前进后退：通过控制左组轮和右组轮的配合实现。pwm调速使其更平滑

循迹功能：基于光电传感器原理，通过判断黑线和白线来决定左转或者右转

跟随功能：通过超声波测出小车和跟随物的距离决定移动方向

避障功能：通过超声波检测出前方障碍物，做出改变方向的决定

语音模块控制：多种语音改变多种引脚的电平，通过语音控制实现以上多种功能的切换

old屏显示速度：将测速模块的数据通过oled屏显示

远程控制：支持蓝牙、4g以及WiFi控制小车

三、相关代码

1、让小车动起来

IA1输入高电平，IA1输入低电平，【OA1 OB1】电机正转；

IA1输入低电平，IA1输入高电平，【OA1 OB1】电机反转；

IA2输入高电平，IA2输入低电平，【OA2 OB2】电机正转；

IA2输入低电平，IA2输入高电平，【OA2 OB2】电机反转；

84ae55d9bea045f2b168e8d4ef1db91c.png

motor.c

#include "motor.h"
void goForward(void)
{
    // 左轮
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);
    // 右轮
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);
}
void goBack(void)
{
    // 左轮
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_SET);
    // 右轮
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_SET);
}
void goLeft(void)
{
    // 左轮
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);
    // 右轮
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);
}
void goRight(void)
{
    // 左轮
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);
    // 右轮
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);
}
void stop(void)
{
    // 左轮
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_2, GPIO_PIN_SET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_SET);
    // 右轮
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);
}

motot.h

#ifndef __MOTOR_H__
#define __MOTOR_H__

#include "main.h"

void goForward(void);
void goBack(void);
void goLeft(void);
void goRight(void);
void stop(void);

#endif

main.c

#include "motor.h"
 
//main函数的while循环部分：
while (1)
{
    goForward();
    HAL_Delay(1000);
    goBack();
    HAL_Delay(1000);
    goLeft();
    HAL_Delay(1000);
    goRight();
    HAL_Delay(1000);
    stop();
    HAL_Delay(1000);
}

2、串口控制小车方向

usart.c（在工程配置的usart.c中添加以下代码）

#include "string.h"
#include "stdio.h"
#include "motor.h"
 
//串口接收缓存（1字节）
uint8_t buf=0;
 
//定义最大接收字节数 200，可根据需求调整
#define UART1_REC_LEN 200
 
// 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
uint8_t UART1_RX_Buffer[UART1_REC_LEN];
 
// 接收状态
// bit15， 接收完成标志
// bit14， 接收到0x0d
// bit13~0， 接收到的有效字节数目
uint16_t UART1_RX_STA=0;
#define SIZE 12
char buffer[SIZE];
 
// 接收完成回调函数，收到一个数据后，在这里处理
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    //判断中断由哪个串口触发
    if(huart->Instance == USART1)
    {
        //判断接收是否完成（UART1_RX_STA bit15 位是否为1）
        if((UART1_RX_STA & 0x8000) == 0)
        {
            //如果已经收到了 0x0d （回车），
            if(UART1_RX_STA & 0x4000)
            {
                //判断是否收到 0x0a （换行）
                if(buf == 0x0a)
                {
                    //如果 0x0a和0x0d都收到，则将bit15位置为1
                    UART1_RX_STA |= 0x8000;
                    //车控指令
                    if(!strcmp(UART1_RX_Buffer, "M1"))
                        goForward();
                    else if(!strcmp(UART1_RX_Buffer, "M2"))
                        goBack();
                    else if(!strcmp(UART1_RX_Buffer, "M3"))
                        goLeft();
                    else if(!strcmp(UART1_RX_Buffer, "M4"))
                        goRight();
                    else
                        stop();
                    memset(UART1_RX_Buffer, 0, UART1_REC_LEN);
                    UART1_RX_STA = 0;
                }
                else
                    //否则认为接收错误，重新开始
                    UART1_RX_STA = 0;
            }
            else // 如果没有收到了 0x0d （回车）            
            {
                //则先判断收到的这个字符是否是 0x0d （回车）
                if(buf == 0x0d)
                {
                    //是的话则将 bit14 位置为1
                    UART1_RX_STA |= 0x4000;
                }
                else
                {
                    //否则将接收到的数据保存在缓存数组里
                    UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
                    UART1_RX_STA++;
                    //如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
                    if(UART1_RX_STA > UART1_REC_LEN - 1)
                        UART1_RX_STA = 0;
                }
            }
        }
        //重新开启中断
        HAL_UART_Receive_IT(&huart1, &buf, 1);
    }
}
int fputc(int ch, FILE *f)
{
    unsigned char temp[1]={ch};
    HAL_UART_Transmit(&huart1,temp,1,0xffff);
    return ch;
}

注：主函数main.c中需要将中断打开，同时在点开魔术棒将u8勾上 如下：

779d93b82d364c509493538721fbf5b8.png

#include "motor.h"
extern uint8_t buf;
//main函数
HAL_UART_Receive_IT(&huart1, &buf, 1);

3、串口点动控制小车

在usart.c车控指令处进行修改 如下：

if (!strcmp(UART1_RX_Buffer, "M1"))
{
    goForward();
    HAL_Delay(10);
}
else if (!strcmp(UART1_RX_Buffer, "M2"))
{
    goBack();
    HAL_Delay(10);
}
else if (!strcmp(UART1_RX_Buffer, "M3"))
{
    goLeft();
    HAL_Delay(10);
}
else if (!strcmp(UART1_RX_Buffer, "M4"))
{
    goRight();
    HAL_Delay(10);
}
else
    stop();

注：这里的HAL_Delay函数为滴答定时器 若直接如上修改代码 则在串口助手中发出车控指令时会导致程序阻塞 有以下两种解决方法：

1.在主函数中调用以下函数修改滴答定时器优先级

HAL_NVIC_SetPriority(Systick_IRQn,0,0);

2.通过Cubemx配置滴答定时器优先级

b1833a84c29f46b29507d84aafd3bd82.png

4、硬件PWM调速控制小车前进

c69d4064282a4ca0832053a0a3d605cc.png

caf37676e1d4473c9e2bae0d5842401a.png

main.c

// main函数里
HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&htim2,TIM_CHANNEL_2);
while (1)
{
    __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, 8);
    __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, 8);
    HAL_Delay(1000);
    __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, 10);
    __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, 10);
    HAL_Delay(1000);
    __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1, 15);
    __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2, 15);
    HAL_Delay(1000);
}

注意：此时小车轮子并不能正常改变转动速度转动，原因是L9110电机模块每个控制口需要一高一低才可以动起来，如果PWM有效电平为高电平，则另一个 GPIO口则需要输出低电平才可以驱动轮子，解决方法是将电机模块对应的GPIO口设置低电平驱动即可

a922e14882ac4d469c833c99a8719124.png

5、硬件PWM调速控制小车左右转

main.c

// main函数里
while (1)
{
    __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1,8);
    __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2,15);
    HAL_Delay(1000);
    __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1,15);
    __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2,8);
    HAL_Delay(1000);
}

6、循迹小车

循迹原理

fc30659520bb4773aa9075fe8a0d4a86.png

1.左右循迹模块都照射到白色上——红外返回——都输出低电平——指示灯亮——直走

2.左循迹模块照射到黑色跑道上——左边红外被吸收不返回——左边输出高电平——指示灯灭——需要左转

3.右循迹模块照射到黑色跑道上——右边红外被吸收不返回——右边输出高电平——指示灯灭——需要右转

这里循迹模块是一个传感器，需要获取传感器的值进行相应操作，所以Cubemx中需配置传感器对应引脚为输入模式，如下：

88865d4b357d447fb980444a9dd94bc0.png

相关代码

main.c

#define LeftWheel_Value HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_3)
#define RightWheel_Value HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_4)
 
// main函数里
while (1)
{
    if (LeftWheel_Value == GPIO_PIN_RESET && RightWheel_Value == GPIO_PIN_RESET)
        goForward();
    if (LeftWheel_Value == GPIO_PIN_SET && RightWheel_Value == GPIO_PIN_RESET)
        goLeft();
    if (LeftWheel_Value == GPIO_PIN_RESET && RightWheel_Value == GPIO_PIN_SET)
        goRight();
    if (LeftWheel_Value == GPIO_PIN_SET && RightWheel_Value == GPIO_PIN_SET)
        stop();
}

7、解决平滑转弯问题

#define LeftWheel_Value HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_3)
#define RightWheel_Value HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_4)
// main函数里
while (1)
{
    if(LeftWheel_Value == GPIO_PIN_RESET && RightWheel_Value == GPIO_PIN_RESET)
    {
        __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1,19);
        __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2,19);
    }
    if(LeftWheel_Value == GPIO_PIN_SET && RightWheel_Value == GPIO_PIN_RESET)
    {
        __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1,15);
        __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2,8);
    }
    if(LeftWheel_Value == GPIO_PIN_RESET && RightWheel_Value == GPIO_PIN_SET)
    {
        __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1,8);
        __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2,15);
    }
    if(LeftWheel_Value == GPIO_PIN_SET && RightWheel_Value == GPIO_PIN_SET)
    {
        __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_1,0);
        __HAL_TIM_SetCompare(&htim2, TIM_CHANNEL_2,0);
    }
}

8.跟随/避障小车

原理：

  • 左边跟随模块能返回红外，输出低电平，右边不能返回，输出高电平，说明物体在左边，需要左转
  • 右边跟随模块能返回红外，输出低电平，左边不能返回，输出高电平，说明物体在右边，需要右转

相关代码

main.c

#define LeftWheel_Value HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_5)
#define RightWheel_Value HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6)
// main函数里
while (1)
{
    if(LeftWheel_Value == GPIO_PIN_RESET && RightWheel_Value == GPIO_PIN_RESET)
        goForward();
    if(LeftWheel_Value == GPIO_PIN_SET && RightWheel_Value == GPIO_PIN_RESET)
        goRight();
    if(LeftWheel_Value == GPIO_PIN_RESET && RightWheel_Value == GPIO_PIN_SET)
        goLeft();
    if(LeftWheel_Value == GPIO_PIN_SET && RightWheel_Value == GPIO_PIN_SET)
        stop();
}

9、摇头避障小车

9.1 封装摇头功能

Cubemx配置

f3c108804e164ae9b4d65551f7570d85.png

上图的预分频值和重装值通过公式代入得出，这里设置周期为20ms，公式如下：

6d007f4f0f8846388eb2c81d5ae73d6e.png

如果周期为20ms，则 PSC=7199，ARR=199。 

sg90模块角度控制：

0.5ms-------------0度； 2.5% 对应函数中CCRx为5

1.0ms------------45度； 5.0% 对应函数中CCRx为10

1.5ms------------90度； 7.5% 对应函数中CCRx为15(这里经过调试发现17比较接近于90°)

2.0ms-----------135度； 10.0% 对应函数中CCRx为20

2.5ms-----------180度； 12.5% 对应函数中CCRx为25

09b2b7e9fb5e4722b43a688c4286a36a.png

相关代码

sg90.c

#include "sg90.h"
#include "gpio.h"
#include "tim.h"
 
void initSG90(void)//初始化90度
{
    HAL_TIM_PWM_Start(&htim4,TIM_CHANNEL_4); //启动定时器4
    __HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_4, 17); //将舵机置为90度
}
 
void sgMiddle(void)
{
    __HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_4, 17); //将舵机置为90度
}
 
void sgRight(void)
{
    __HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_4, 5); //将舵机置为0度
}
 
void sgLeft(void)
{
    __HAL_TIM_SetCompare(&htim4, TIM_CHANNEL_4, 25); //将舵机置为180度
}

sg90.h

#ifndef __SG90_H__
#define __SG90_H__
 
void initSG90(void);
void sgMiddle(void);
void sgRight(void);
void sgLeft(void);
 
#endif

main.c

#define LeftWheel_Value HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_5)
#define RightWheel_Value HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6)
// main函数里
while (1)
{
    if(LeftWheel_Value == GPIO_PIN_RESET && RightWheel_Value == GPIO_PIN_RESET)
        goForward();
    if(LeftWheel_Value == GPIO_PIN_SET && RightWheel_Value == GPIO_PIN_RESET)
        goRight();
    if(LeftWheel_Value == GPIO_PIN_RESET && RightWheel_Value == GPIO_PIN_SET)
        goLeft();
    if(LeftWheel_Value == GPIO_PIN_SET && RightWheel_Value == GPIO_PIN_SET)
        stop();
}

9.2 封装超声波传感器

Cubrmx配置

b405e93ac1414e5f8c660764f0f01588.png

sr04.c

#include "sr04.h"
#include "gpio.h"
#include "tim.h"
 
//使用TIM2来做us级延时函数
void TIM2_Delay_us(uint16_t n_us)
{
    /* 使能定时器2计数 */
    __HAL_TIM_ENABLE(&htim2);
    __HAL_TIM_SetCounter(&htim2, 0);
    while(__HAL_TIM_GetCounter(&htim2) < ((1 * n_us)-1) );
    /* 关闭定时器2计数 */
    __HAL_TIM_DISABLE(&htim2);
}
 
double get_distance(void)
{
    int cnt=0;
    //1. Trig ，给Trig端口至少10us的高电平
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, GPIO_PIN_SET);//拉高
    TIM2_Delay_us(20);
    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_7, GPIO_PIN_RESET);//拉低
 
    //2. echo由低电平跳转到高电平，表示开始发送波
    //波发出去的那一下，开始启动定时器
    while(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_RESET);//等待输入电平拉高
    HAL_TIM_Base_Start(&htim2);
    __HAL_TIM_SetCounter(&htim2,0);
 
    //3. 由高电平跳转回低电平，表示波回来了
    while(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_8) == GPIO_PIN_SET);//等待输入电平变低
    //波回来的那一下，我们开始停止定时器
    HAL_TIM_Base_Stop(&htim2);
 
    //4. 计算出中间经过多少时间
    cnt = __HAL_TIM_GetCounter(&htim2);
 
    //5. 距离 = 速度 （340m/s）* 时间/2（计数1次表示1us）
    return (cnt*340/2*0.000001*100); //单位：cm
}

sr04.h

#ifndef __SR04_H__
#define __SR04_H__
 
double get_distance(void);
 
#endif

main.c

#define MIDDLE 0
#define LEFT 1
#define RIGHT 2

char dir;
double disMiddle;
double disLeft;
double disRight;

while (1)
{
    if(dir != MIDDLE){
        sgMiddle();
        dir = MIDDLE;
        HAL_Delay(300);
    }
    disMiddle = get_distance();
 
    if(disMiddle > 35){
    //前进
    }
    else
    {
        //停止
        //测左边距离
        sgLeft();
 
        HAL_Delay(300);
        disLeft = get_distance();
 
        sgMiddle();
        HAL_Delay(300);
 
        sgRight();
        dir = RIGHT;
        HAL_Delay(300);
        disRight = get_distance();
    }
}

9.3 封装电机驱动

while (1)
{
    if(dir != MIDDLE){
        sgMiddle();
        dir = MIDDLE;
        HAL_Delay(300);
    }
    disMiddle = get_distance();
 
    if(disMiddle > 35){
        //前进
        goForward();
    }else if(disMiddle < 10){
        goBack();
    }else
    {
        //停止
        stop();
        //测左边距离
        sgLeft();
        HAL_Delay(300);
        disLeft = get_distance();
 
        sgMiddle();
        HAL_Delay(300);
 
        sgRight();
        dir = RIGHT;
        HAL_Delay(300);
        disRight = get_distance();
 
        if(disLeft < disRight){
            goRight();
            HAL_Delay(150);
            stop();
        }
        if(disRight < disLeft){
            goLeft();
            HAL_Delay(150);
        stop();
        }
    }
    HAL_Delay(50);
}

10、小车测速数据通过串口上传到上位机

Cubemx配置

8f6d9b3cc520454790e0ebf5126fae87.png

c08a5baef2494e7cbe736420a0c396f3.png

a718dbbf176b41a8a44051dfa809126d.png

main.c

//中断定时服务函数
unsigned int speedCnt;
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    if (GPIO_Pin == GPIO_PIN_14)
        if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_14) == GPIO_PIN_RESET)
            speedCnt++;
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    printf("speed: %d\r\n", speedCnt);
    speedCnt = 0;
}
main函数里：
HAL_TIM_Base_Start_IT(&htim2);

11、串口控制小车并使用Oled屏显示速度

oled.c

#include "oled.h"
#include "i2c.h"
#include "oledfont.h"
 
void Oled_Write_Cmd(uint8_t dataCmd)
{
	
	HAL_I2C_Mem_Write(&hi2c1, 0x78, 0x00, I2C_MEMADD_SIZE_8BIT,
										&dataCmd, 1, 0xff);
}
 
void Oled_Write_Data(uint8_t dataData)
{
	HAL_I2C_Mem_Write(&hi2c1, 0x78, 0x40, I2C_MEMADD_SIZE_8BIT,
										&dataData, 1, 0xff);
}
 
void Oled_Init(void){
	Oled_Write_Cmd(0xAE);//--display off
	Oled_Write_Cmd(0x00);//---set low column address
	Oled_Write_Cmd(0x10);//---set high column address
	Oled_Write_Cmd(0x40);//--set start line address  
	Oled_Write_Cmd(0xB0);//--set page address
	Oled_Write_Cmd(0x81); // contract control
	Oled_Write_Cmd(0xFF);//--128   
	Oled_Write_Cmd(0xA1);//set segment remap 
	Oled_Write_Cmd(0xA6);//--normal / reverse
	Oled_Write_Cmd(0xA8);//--set multiplex ratio(1 to 64)
	Oled_Write_Cmd(0x3F);//--1/32 duty
	Oled_Write_Cmd(0xC8);//Com scan direction
	Oled_Write_Cmd(0xD3);//-set display offset
	Oled_Write_Cmd(0x00);//
	
	Oled_Write_Cmd(0xD5);//set osc division
	Oled_Write_Cmd(0x80);//
	
	Oled_Write_Cmd(0xD8);//set area color mode off
	Oled_Write_Cmd(0x05);//
	
	Oled_Write_Cmd(0xD9);//Set Pre-Charge Period
	Oled_Write_Cmd(0xF1);//
	
	Oled_Write_Cmd(0xDA);//set com pin configuartion
	Oled_Write_Cmd(0x12);//
	
	Oled_Write_Cmd(0xDB);//set Vcomh
	Oled_Write_Cmd(0x30);//
	
	Oled_Write_Cmd(0x8D);//set charge pump enable
	Oled_Write_Cmd(0x14);//
	
	Oled_Write_Cmd(0xAF);//--turn on oled panel		
}
 
void Oled_Screen_Clear(void){
	char i,n;
	Oled_Write_Cmd (0x20);                    //set memory addressing mode
	Oled_Write_Cmd (0x02);                    //page addressing mode
 
	for(i=0;i<8;i++){
		Oled_Write_Cmd(0xb0+i);               //éè??ò3μ??·￡¨0~7￡?
		Oled_Write_Cmd(0x00);                 //éè????ê??????aáDμíμ??·
		Oled_Write_Cmd(0x10);                 //éè????ê??????aáD??μ??·   
		for(n=0;n<128;n++)Oled_Write_Data(0x00); 			
	}	
}
 
void Oled_Show_Char(char row,char col,char oledChar){ //row*2-2
	unsigned int  i;
	Oled_Write_Cmd(0xb0+(row*2-2));                           //page 0
	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
	Oled_Write_Cmd(0x10+(col>>4));                            //high	
	for(i=((oledChar-32)*16);i<((oledChar-32)*16+8);i++){
		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
	}
 
	Oled_Write_Cmd(0xb0+(row*2-1));                           //page 1
	Oled_Write_Cmd(0x00+(col&0x0f));                          //low
	Oled_Write_Cmd(0x10+(col>>4));                            //high
	for(i=((oledChar-32)*16+8);i<((oledChar-32)*16+8+8);i++){
		Oled_Write_Data(F8X16[i]);                            //写数据oledTable1
	}		
}
 
 
/******************************************************************************/
// 函数名称：Oled_Show_Char 
// 输入参数：oledChar 
// 输出参数：无 
// 函数功能：OLED显示单个字符
/******************************************************************************/
void Oled_Show_Str(char row,char col,char *str){
	while(*str!=0){
		Oled_Show_Char(row,col,*str);
		str++;
		col += 8;	
	}		
}

显示代码实现

extern uint8_t buf;
unsigned int speedCnt = 0;
char speedMes[24];  //主程序发送速度数据的字符串缓冲区
 
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	if (GPIO_Pin == GPIO_PIN_14)
		if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_14) == GPIO_PIN_RESET)
			speedCnt++;
}
 
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	printf("speed: %d\r\n", speedCnt);
	sprintf(speedMes,"speed:%2d cm/s",speedCnt);//串口数据的字符串拼装，speed是格子，每个格子1cm
	Oled_Show_Str(2,2,speedMes);
	speedCnt = 0;
}

12、Wi-Fi测速小车并本地Oled显示

esp8266.c

#include "esp8266.h"
#include "stdio.h"

//1 工作在路由模式
char LYMO[] = "AT+CWMODE=2\r\n";
//2 使能多链接
char DLJ[] = "AT+CIPMUX=1\r\n"; 
//3 建立TCPServer
char JLFW[] = "AT+CIPSERVER=1\r\n"; // default port = 333 


char AT_OK_Flag = 0;				//OK返回值的标志位
char AT_Connect_Net_Flag = 0;		//WIFI GOT IP返回值的标志位
char Client_Connect_Flag = 0;

void initWifi_AP(void)
{
	printf(LYMO);
	while(!AT_OK_Flag) HAL_Delay(50);
	AT_OK_Flag = 0;

	printf(DLJ);
	while(!Client_Connect_Flag) HAL_Delay(50);
	AT_OK_Flag = 0;
}

void waitConnect(void)
{
	printf(JLFW);
	while(!AT_OK_Flag) HAL_Delay(50);
	AT_OK_Flag = 0;	
}

esp8266.h

#ifndef __ESP8266_H_
#define __ESP8266_H_

void initWifi_AP(void);
void waitConnect(void);

#endif

usart.c

#include "motor.h"
#include "stdio.h"
#include "string.h"

//串口接收缓存（1字节）
uint8_t buf=0;
 
//定义最大接收字节数 200，可根据需求调整
#define UART1_REC_LEN 200
 
// 接收缓冲, 串口接收到的数据放在这个数组里，最大UART1_REC_LEN个字节
uint8_t UART1_RX_Buffer[UART1_REC_LEN];
 
// 接收状态
// bit15， 接收完成标志
// bit14， 接收到0x0d
// bit13~0， 接收到的有效字节数目
uint16_t UART1_RX_STA=0;

extern char AT_OK_Flag;				//OK返回值的标志位
extern char AT_Connect_Net_Flag ;		//WIFI GOT IP返回值的标志位
extern char Client_Connect_Flag;

#define SIZE 12
char buffer[SIZE];
 
// 接收完成回调函数，收到一个数据后，在这里处理
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    //判断中断由哪个串口触发
    if(huart->Instance == USART1)
    {
        //判断接收是否完成（UART1_RX_STA bit15 位是否为1）
        if((UART1_RX_STA & 0x8000) == 0)
        {
            //如果已经收到了 0x0d （回车），
            if(UART1_RX_STA & 0x4000)
            {
                //判断是否收到 0x0a （换行）
                if(buf == 0x0a)
                {
                    //如果 0x0a和0x0d都收到，则将bit15位置为1
                    UART1_RX_STA |= 0x8000;
									
										if(!strcmp(UART1_RX_Buffer, "WIFI GOT IP"))
											AT_Connect_Net_Flag = 1;
										
										// 查看是否收到 OK
										if(!strcmp(UART1_RX_Buffer, "OK"))
											AT_OK_Flag = 1;
										
										// 查看是否收到 FAIL
										if(!strcmp(UART1_RX_Buffer, "0,CONNECT"))	
											Client_Connect_Flag = 1;
                    
                    if(!strcmp(UART1_RX_Buffer, "+IPD,0,4:M1"))
                        goForward();
                    else if(!strcmp(UART1_RX_Buffer, "+IPD,0,4:M2"))
                        goBack();
                    else if(!strcmp(UART1_RX_Buffer, "+IPD,0,4:M3"))
                        goLeft();
                    else if(!strcmp(UART1_RX_Buffer, "+IPD,0,4:M4"))
                        goRight();
                    else if(!strcmp(UART1_RX_Buffer, "+IPD,0,4:M0"))
                        stop();
                    memset(UART1_RX_Buffer, 0, UART1_REC_LEN);
                    UART1_RX_STA = 0;
                }
                else
                    //否则认为接收错误，重新开始
                    UART1_RX_STA = 0;
            }
            else // 如果没有收到了 0x0d （回车）            
            {
                //则先判断收到的这个字符是否是 0x0d （回车）
                if(buf == 0x0d)
                {
                    //是的话则将 bit14 位置为1
                    UART1_RX_STA |= 0x4000;
                }
                else
                {
                    //否则将接收到的数据保存在缓存数组里
                    UART1_RX_Buffer[UART1_RX_STA & 0X3FFF] = buf;
                    UART1_RX_STA++;
                    //如果接收数据大于UART1_REC_LEN（200字节），则重新开始接收
                    if(UART1_RX_STA > UART1_REC_LEN - 1)
                        UART1_RX_STA = 0;
                }
            }
        }
        //重新开启中断
        HAL_UART_Receive_IT(&huart1, &buf, 1);
    }
}
int fputc(int ch, FILE *f)
{
    unsigned char temp[1]={ch};
    HAL_UART_Transmit(&huart1,temp,1,0xffff);
    return ch;
}

main.c

#include "motor.h"
#include "stdio.h"
#include "oled.h"
#include "esp8266.h"

extern uint8_t buf;
extern uint8_t buf;
unsigned int speedCnt = 0;
char speedMes[24];  //主程序发送速度数据的字符串缓冲区

//发送数据
char FSSJ[] = "AT+CIPSEND=0,5\r\n";

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	if (GPIO_Pin == GPIO_PIN_14)
		if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_14) == GPIO_PIN_RESET)
			speedCnt++;
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
	printf(FSSJ);
	HAL_Delay(50);
	sprintf(speedMes,"%2dcm/s",speedCnt);//串口数据的字符串拼装，speed是格子，每个格子1cm
	printf(speedMes);
	Oled_Show_Str(2,2,speedMes);
	speedCnt = 0;
}

int main(void)
{
	HAL_UART_Receive_IT(&huart1, &buf, 1);
	HAL_TIM_Base_Start_IT(&htim2);
	Oled_Init();
	Oled_Screen_Clear();
	
	HAL_Delay(1000);
	initWifi_AP();
	waitConnect();
}

 这里由于定时器2中用到延时函数，所以需要通过Cubemx配置滴答定时器中断优先级，如下：

13、语音控制小车

e3127e7d7252485ea291d1786834c3b2.png

#include "sg90.h"
#include "sr04.h"
#include "motor.h"
#include "oled.h"
#include "string.h"
#define MIDDLE 0
#define LEFT 1
#define RIGHT 2
#define BZ 1
#define XJ 2
#define GS 3
#define LeftWheel_Value_XJ HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_3)
#define RightWheel_Value_XJ HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_4)
#define LeftWheel_Value_GS HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_8)
#define RightWheel_Value_GS HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_9)
#define XJ_VALUE HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_14)
#define GS_VALUE HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_15)
#define BZ_VALUE HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_13)
char dir;
void xunjiMode()
{
    if(LeftWheel_Value_XJ == GPIO_PIN_RESET && RightWheel_Value_XJ == GPIO_PIN_RESET)
        goForward();
    if(LeftWheel_Value_XJ == GPIO_PIN_SET && RightWheel_Value_XJ == GPIO_PIN_RESET)
        goLeft();
    if(LeftWheel_Value_XJ == GPIO_PIN_RESET && RightWheel_Value_XJ == GPIO_PIN_SET)
        goRight();
    if(LeftWheel_Value_XJ == GPIO_PIN_SET && RightWheel_Value_XJ == GPIO_PIN_SET)
        stop();
}
void gensuiMode()
{
    if(LeftWheel_Value_GS == GPIO_PIN_RESET && RightWheel_Value_GS == GPIO_PIN_RESET)
        goForward();
    if(LeftWheel_Value_GS == GPIO_PIN_SET && RightWheel_Value_GS == GPIO_PIN_RESET)
        goRight();
    if(LeftWheel_Value_GS == GPIO_PIN_RESET && RightWheel_Value_GS == GPIO_PIN_SET)
        goLeft();
    if(LeftWheel_Value_GS == GPIO_PIN_SET && RightWheel_Value_GS == GPIO_PIN_SET)
        stop();
}
void bizhangMode()
{
    double disMiddle;
    double disLeft;
    double disRight;
    if(dir != MIDDLE){
        sgMiddle();
        dir = MIDDLE;
        HAL_Delay(300);
    }
    disMiddle = get_distance();
    if(disMiddle > 35){
        //前进
        goForward();
    }else if(disMiddle < 10){
        goBack();
    }else
    {
        //停止
        stop();
        //测左边距离
        sgLeft();
        HAL_Delay(300);
        disLeft = get_distance();
        sgMiddle();
        HAL_Delay(300);
        sgRight();
        dir = RIGHT;
        HAL_Delay(300);
        disRight = get_distance();
        if(disLeft < disRight){
            goRight();
            HAL_Delay(150);
            stop();
        }
        if(disRight < disLeft){
            goLeft();
            HAL_Delay(150);
            stop();
        }
    }
    HAL_Delay(50);
}
int main(void)
{
    int mark = 0;
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_TIM4_Init();
    MX_TIM2_Init();
    MX_I2C1_Init();
 
    initSG90();
    HAL_Delay(1000);
    dir = MIDDLE;
    Oled_Init();
    Oled_Screen_Clear();
 
    Oled_Show_Str(2,2,"-----Ready----");
    while (1)
    {
        if(XJ_VALUE == GPIO_PIN_RESET && GS_VALUE == GPIO_PIN_SET && BZ_VALUE ==
                GPIO_PIN_SET)
        {
            if(mark != XJ)
            {
                Oled_Screen_Clear();
                Oled_Show_Str(2,2,"-----XunJi----");
            }
            mark = XJ;
            xunjiMode();
        }
        //满足循迹模式的条件
        if(XJ_VALUE == GPIO_PIN_SET && GS_VALUE == GPIO_PIN_RESET && BZ_VALUE ==
                GPIO_PIN_SET)
        {
            if(mark != GS)
            {
                Oled_Screen_Clear();
                Oled_Show_Str(2,2,"-----GenSui----");
            }
            mark = GS;
            gensuiMode();
        }
        //满足避障模式的条件
        if(XJ_VALUE == GPIO_PIN_SET && GS_VALUE == GPIO_PIN_SET && BZ_VALUE ==
                GPIO_PIN_RESET)
        {
            if(mark != BZ)
            {
                Oled_Screen_Clear();
                Oled_Show_Str(2,2,"-----BiZhang----");
            }
            mark = BZ;
            bizhangMode();
        }
        HAL_Delay(50);
    }
}

嵌入式JunG
关注
  • 25
    点赞
  • 踩
  • 62
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于STM32智能小车
12-17
智能小车是一个比较好的项目，对于刚刚入门STM32的人来说，就是需要做一些小的项目去提高自己的编程水平，智能小车涉及到多模块编程，需要编写者熟悉各种模块，并学会如何去调试各种模块。
智能小车+stm32+超声波.zip
06-29
超声波源码以及小车的控制，小车控制的没加到项目里面，但是源码在里面！
stm32循迹小车详细制作过程（附加完全版代码）
热门推荐
wzy的博客
01-14 12万+
stm32循迹小车详细制作过程 一.材料准备 1、主控板 Stm32f103c8t6 (推荐，便宜够用) 2、下载器 USB转TTL串口模块 3、电源 12v锂电池组、配套充电器（推荐下图这种，方便，好接线，12v！12v! 12v！） 4、电机驱动模块 L298n电机驱动模块（尽量多备一两个，容易烧） 5、循迹模块 TCRT5000循迹模块（多买几个，四个吧） 6、杜邦线 公对公、母对母、公对母（都买上，不贵，消耗品） 7、开关 避免出现意外还是备一个吧 8、小车底座 有四个轮的，三个轮的（
基于STM32和人工智能的智能小车系统
最新发布
2401_84204806的博客
06-19 1421
本教程详细介绍了如何在STM32嵌入式系统中结合人工智能技术实现智能小车系统，从硬件选择、软件实现到系统配置和应用场景都进行了全面的阐述。通过合理的技术选择和系统设计，可以构建一个高效且功能强大的智能小车系统。
基于STM32的智能循迹避障小车
m0_55933541的博客
01-10 2万+
为了在日常实验教学中融入智能车的元素，本设计采用多传感器协同策略，开发一款基于STM32智能循迹避障小车。研究内容主要包括系统的整体方案设计、系统硬件设计与选择、多传感器协同策略、软件设计等，并在此基础上进行实际H型轨迹循迹试验，验证该方案的可靠性及该系统的功能的完整性。
基于stm32的智能小车(远程控制、避障、循迹)
kk1kk2kk3kk4的博客
12-01 4866
学完stm32，总是想做点东西“大显身手”一下，智能小车就成了首选项目，其核心只是就是PWM输出，I/O口引脚电平判断。由于我们做的控制功能可以使用2.4G控制，也可以使用蓝牙进行控制，两种传输方式所需购买的模块不同，已在硬件名单中加以区分，接下来就一步步的实现。
stm32智能小车红外避障
wuyiyu_的博客
04-30 3524
红外避障模块是一种常用于智能小车、机器人等设备中的传感器模块，用于检测周围环境中的障碍物。它通常由红外发射器和红外接收器组成，并能够通过红外光线来探测周围物体的距离和位置。正前方有障碍时绿灯 （L1）亮起，使用前通过调节红外模块的旋钮，控制红外检测的距离。顺时针扭动缩短测距的长度，逆时针增加测距的长度。下篇文章为大家介绍 智能小车循迹。
【单片机项目】制作一辆基于STM32的智能小车——HC-SR04超声波模块
weixin_45675704的博客
04-02 2930
HC-SR04超声波避障模块 HC-SR04 超声波测距模块可提供 2cm-400cm 的非接触式距离感测功能， 测距精度可达高到 3mm；模块包括超声波发射器、接收器与控制电路。 基本工作原理：  （1）采用IO口TRIG触发测距，给至少10us的高电平信号; （2）模块自动发送8个40khz的方波，自动检测是否有信号返回； （3）有信号返回，通过IO口ECHO输出一个高电平，高电平持续的时间就...
STM32F103C8T6 蓝牙遥控 两轮小车 代码 超声波
04-14
STM32F103C8T6蓝牙遥控两轮小车代码+超声波检测 自己学习用的 注释较详细 使用L298N驱动电机 支持定时器输出PWM调速 两轮差速控制转向 超声波检测30cm停车
stm32f1 平衡小车 建造章节（二）
qq_41821562的博客
04-21 769
大家好，本人小白一个，利用一些课外时间制作32平衡小车，博客的主要内容是记录自己在制作过程中遇到的鸡毛蒜皮的困难，以及搭配自己的制作思路。 话不多说，开始今天上午的任务。 本章节主要是想要实现小车 PID保持平衡的趋势，具体精确参数下午再调试。 第一步：让小车先动起来。 （1）先检验小车电机是否有问题，直接给电机的两个12V线供上12V和GND（没有顺序，大不了正反转，切记不要超过12V哦...
STM32C8T6控制智能小车代码
szq0909的博客
07-04 4274
一个STM32控制小车的代码，包含小车的前进后退转弯调速蓝牙通信等
stm32红外避障
10-18
基于stm32开发的具有红外避障功能的c语言程序，小车自动避障
基于stm32库3.5的小车红外避障程序
07-11
基于stm32库3.5的小车红外避障程序
基于STM32智能小车避障系统的设计.pptx
10-17
"基于STM32智能小车避障系统的设计" 智能小车避障系统是当前研究的热点，具有广泛的应用前景。基于STM32单片机的智能小车避障系统是其中的一种，旨在提高小车的自主性和适应性，使其能够在复杂环境中自主避障。 ...
基于stm32及proteus智能小车仿真
12-10
【基于STM32及Proteus智能小车仿真的详细解析】 在电子工程领域，STM32微控制器因其丰富的资源和高性能，被广泛应用于各种智能系统设计，包括智能小车项目。本项目“基于STM32及Proteus智能小车仿真”就是这样一个...
基于STM32的智能小车源代码.zip
06-15
在这个"基于STM32的智能小车源代码.zip"压缩包中，我们可以期待找到与智能小车设计相关的软件资源，特别是针对STM32微控制器的编程代码。 智能小车通常包括以下几个关键部分： 1. **硬件平台**：智能小车的基础是...
基于STM32智能循迹避障小车(课程设计报告)
04-27
【基于STM32智能循迹避障小车(课程设计报告)】的项目是一个典型的嵌入式系统开发案例，主要用于教育和研究目的，如课程设计和毕业设计。在这个项目中，STM32微控制器作为核心处理器，实现了小车的路径追踪和障碍物...
STM32智能小车（循迹、跟随、避障、测速、蓝牙、wifi、4g、语音识别）总结
wei_Embedded_z的博客
11-02 2万+
STM32智能小车（循迹、跟随、避障、测速、蓝牙、wife、4g、语音识别）总结循迹小车 循迹小车 3.跟随/避障小车 4.测速小车 5.远程控制小车6.语音控制小车
电赛小车常用硬件解析（蓝牙遥控，循迹）
m0_58326153的博客
10-24 1万+
本文针对（蓝牙遥控、循迹）智能小车项目的硬件部分进行解析，包括单片机、电机、电机驱动、降压模块、循迹模块。并对单片机学习方法，给出一点自己不成熟的小建议。
STM32驱动超声波模块
07-27
要在STM32上驱动超声波模块，你可以按照以下步骤进行操作： 1. 首先，连接超声波模块到STM32开发板。将VCC引脚连接到5V电源，GND引脚连接到地线，Trig引脚连接到一个输出引脚（用于发射超声波信号），Echo引脚连接到一个输入引脚（用于接收返回的超声波信号）。 2. 在你的STM32工程中，包含"hc_sr04.h"头文件，并在代码中声明一个全局变量`float Dist_cm`，用于存储测量到的距离。 3. 在代码中调用`HC_SR04_Init()`函数，用于初始化超声波模块。 4. 在主循环中，发送一个至少10us的TTL电平信号来触发超声波模块。可以使用STM32的GPIO库来设置输出引脚的电平。 5. 等待一段时间，让超声波模块发出8个40KHZ的脉冲。 6. 接收回响信号，根据高电平的时间来计算出距离。可以使用STM32的GPIO库来读取输入引脚的电平，并根据计算公式`T(s) * 340(m/s) / 2`计算距离。 请注意，具体的代码实现可能会因为使用的STM32型号和开发环境而有所不同。你需要根据你的具体情况进行相应的调整和修改。 #### 引用[.reference_title] - *1* *2* [STM32驱动HC-SR04超声波模块](https://blog.csdn.net/m0_49476241/article/details/130179740)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] - *3* [【STM32篇】驱动HC_SR04超声波测距模块](https://blog.csdn.net/we_long/article/details/128671122)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值