stm32基于标准库写的智能小车

已于 2023-10-28 13:52:26 修改
阅读量1.6k 收藏 55
点赞数 9
文章标签： c语言 stm32 嵌入式硬件
于 2023-02-21 16:20:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tyc123tyc/article/details/129138440
版权

智能小车代码实测过，可以直接用

  1. 硬件部分：舵机用的是sg90，超声波模块用的是HC-SR04，蓝牙用的是HC-05，蜂鸣器模块，循迹模块，减压模块，电池用的是可充电的18650锂电池，电机用的是L298N，杜邦线*n，OLED模块四针0.96寸，面包板，st-link

  1. 软件部分：

智能小车拥有三种模式，三种模式通过按键切换。（显示屏一直都可以显示各种数据）

模式一：小车可以自主的任意游走，且不会碰到障碍物，当达到危险距离的时候，蜂鸣器会发出警报，OLED显示障碍物距离

模式二 ：小车循迹避障

模式三：蓝牙控制小车运动

  1. 下面是小车的图片（杜邦线飞线跳线多的要死）

  1. 下面是代码部分

主函数代码


#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "PWM.h"
#include "motor.h"
#include "key.h"
#include "Timer.h"
#include "HCSR04.h"
#include "Servo.h"
#include "xunji.h"
#include "HC_05.h"
#include <stdio.h>


#ifdef __GNUC__
#define PUTCHAR_PROTOTYPE int __io_putchar(int ch)
#else
#define PUTCHAR_PROTOTYPE int fputc(int ch, FILE *f)
#endif 

uint8_t KeyNum;
uint8_t num3,num2,num1;
//    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
//    
//    GPIO_InitTypeDef GPIO_InitStructure;
//    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
//    GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_0;
//    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
//    GPIO_Init(GPIOA, &GPIO_InitStructure);
//GPIO_ResetBits (GPIOA ,GPIO_Pin_0);
float Angle = 90;
uint64_t numlen(uint64_t num)
{
    uint64_t len = 1;      
    for(; num > 9; ++len)    
        num /= 10;             
    return len;             
}


//ÖжϷþÎñº¯Êý  
u8 i;
u8 flag;  //¶¨ÒåÒ»¸ö±ê־λ
void USART1_IRQHandler(void)  
  
{  
     if(USART_GetITStatus(USART1, USART_IT_RXNE) == SET)      //¼ì²éÖ¸¶¨µÄ USART1 ÖжϷ¢ÉúÓë·ñ
      { 
            USART_ClearITPendingBit(USART1, USART_IT_RXNE);   //Çå³ý USART1 µÄÖжϴý´¦Àíλ
            GPIO_ResetBits(GPIOC,GPIO_Pin_13);                 //ÉèÖÃLEDµÆ×÷ΪÖжϷ¢ÉúÓë·ñµÄָʾµÆ
            i=  USART_ReceiveData(USART1);                    //·µ»Ø USART1 ×î½ü½ÓÊÕµ½µÄÊý¾Ý
        //ifÓï¾äµÄÄÚÈݲ¿·Ö¿ÉÒÔ±£Ö¤À¶ÑÀ½ÓÊÕµ½µÄflagÊý¾ÝÊÇÕýÈ·µÄ£¬Èç¹û²»¼ÓµÄ»°»áµ¼Ö½ÓÊÕ²»µ½ÕýÈ·µÄÊý¾Ý
          if(i=='0')
                {                 
                     flag=0;
                }
                
            if(i=='1')
                {
                     flag=1;
                }
                
            if(i=='2')
               {
                     flag=2;
                }
               
            if(i=='3')
               {
                                 
                    flag=3;
               }
               
            if(i=='4')
              {
                    flag=4;
              }
              
            if(i=='5')
              {
                    flag=5;
              }
              
            if(i=='6')
             {
                    flag=6;
             }

          }
          
//          USART_ClearITPendingBit(USART1, USART_IT_RXNE);
}



int main(void)
{
    HC_05_Init();
    OLED_Init();
    Motor_Init();
    Key_Init();
    Timer_Init();    
    HC_SR04_Init();
    Servo_Init();
    xunji_config();
    
    OLED_ShowString(1, 1, "Mode:");
    OLED_ShowString(2, 1, "flag:");
//    OLED_ShowString(3, 1, "Right_Duty:00%");
    OLED_ShowString(3, 1, "distance:");    
    OLED_ShowString(1, 10, "Angle:");

    num3=0;    
    num2=0;
    num1=0;
    while (1)
    {
            Servo_SetAngle(90);
            KeyNum = Key_GetNum();


            if(KeyNum==1)
            {
                num1=3;
                OLED_ShowNum(1, 6, num1, 2);
                while(1)
                {
                        int Distance_mm=sonar_mm();                    
                        int Distance_m=Distance_mm/1000;
                        int Distance_m_p=Distance_mm%1000;    
                        
                        
                        OLED_Clear_Part(4,10,16);        
                        OLED_ShowNum(4, 1,Distance_m,numlen(Distance_m));    
                        OLED_ShowChar(4, 1+numlen(Distance_m), '.');        
                        if(Distance_m_p<100)
                        {
                            OLED_ShowChar(4, 1+numlen(Distance_m)+1,'0');                                
                            OLED_ShowNum(4, 1+numlen(Distance_m)+2,Distance_m_p,numlen(Distance_m_p));
                            OLED_ShowChar(4, 1+numlen(Distance_m)+2+numlen(Distance_m_p), 'm');            
                        }else                                                                        
                        {
                            OLED_ShowNum(4, 1+numlen(Distance_m)+1,Distance_m_p,numlen(Distance_m_p));    
                            OLED_ShowChar(4, 1+numlen(Distance_m)+1+numlen(Distance_m_p), 'm');            
                        }
                    Delay_ms (50);    
                    
                    OLED_ShowNum(2, 6, flag, 2);
                    switch(flag)
                         {
                            case 0:stop();         break  ;
                            case 1:run_left ();     break  ;
                            case 2:run_right ();    break  ;
                            case 3:back();     break  ;
                            case 4:run();    break  ;
                            case 5:back_left ();   break  ;
                            case 6:back_right();  break  ;                            
                            default:stop();         break  ;                                                                                                
                         }          
                }
            }
            if(KeyNum==2)//xunji
            {
                num2=2;
                OLED_ShowNum(1, 6, num2, 2);
                while(1)
                {
                        int Distance_mm=sonar_mm();                    
                        int Distance_m=Distance_mm/1000;
                        int Distance_m_p=Distance_mm%1000;    
                        
                        
                        OLED_Clear_Part(4,10,16);        
                        OLED_ShowNum(4, 1,Distance_m,numlen(Distance_m));    
                        OLED_ShowChar(4, 1+numlen(Distance_m), '.');        
                        if(Distance_m_p<100)
                        {
                            OLED_ShowChar(4, 1+numlen(Distance_m)+1,'0');                                
                            OLED_ShowNum(4, 1+numlen(Distance_m)+2,Distance_m_p,numlen(Distance_m_p));
                            OLED_ShowChar(4, 1+numlen(Distance_m)+2+numlen(Distance_m_p), 'm');            
                        }else                                                                        
                        {
                            OLED_ShowNum(4, 1+numlen(Distance_m)+1,Distance_m_p,numlen(Distance_m_p));    
                            OLED_ShowChar(4, 1+numlen(Distance_m)+1+numlen(Distance_m_p), 'm');            
                        }
                    Delay_ms (50);                    
                    
                        
                if(Distance_mm <=400)
                {
                    back();
                    Delay_ms (100);
                    stop();
                }
                if(Distance_mm > 400)//4 is left
                {
                            if(GPIO_ReadInputDataBit (GPIOB,GPIO_Pin_4)==1)//0000
                            {
                                if(GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_7)==1)
                                {
                                    run();
                                    Delay_ms (100);
                                    stop();                            
                                }
                                
                            if(GPIO_ReadInputDataBit (GPIOB,GPIO_Pin_4)==1)//0000
                                {
                                if(GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_7)==0)
                                    {
                                    run_left ();
                                    Delay_ms (100);
                                    stop();                            
                                    }
                                }                            
                            }
                            if(GPIO_ReadInputDataBit (GPIOB,GPIO_Pin_4)==0)//0000
                                {
                                if(GPIO_ReadInputDataBit(GPIOB,GPIO_Pin_7)==1)
                                    {
                                    run_right();
                                    Delay_ms (100);
                                    stop();                            
                                    }
                                }                            
                            }
                            
                                
                }


            }
        
            if(KeyNum == 3)
            {
                num3++;
                OLED_ShowNum(1, 6, num3, 2);
                if(num3 == 1)
                {
                    while(1)
                    {
                        OLED_ShowNum(2, 14, Angle, 3);
                        
                        
                        int Distance_mm=sonar_mm();                    
                        int Distance_m=Distance_mm/1000;
                        int Distance_m_p=Distance_mm%1000;    
                        
                        
                        OLED_Clear_Part(4,10,16);        
                        OLED_ShowNum(4, 1,Distance_m,numlen(Distance_m));    
                        OLED_ShowChar(4, 1+numlen(Distance_m), '.');        
                        if(Distance_m_p<100)
                        {
                            OLED_ShowChar(4, 1+numlen(Distance_m)+1,'0');                                
                            OLED_ShowNum(4, 1+numlen(Distance_m)+2,Distance_m_p,numlen(Distance_m_p));
                            OLED_ShowChar(4, 1+numlen(Distance_m)+2+numlen(Distance_m_p), 'm');            
                        }else                                                                        
                        {
                            OLED_ShowNum(4, 1+numlen(Distance_m)+1,Distance_m_p,numlen(Distance_m_p));    
                            OLED_ShowChar(4, 1+numlen(Distance_m)+1+numlen(Distance_m_p), 'm');            
                        }
                    Delay_ms (50);


//void run//void back//void run_right//void back_right//void run_left//void back_left                        
                        if(Angle == 90)
                        {
                            if( Distance_mm > 400 )
                            {
                                    run();                                
                            }    
                        }    
                        if(Angle == 90)
                        {
                            if( Distance_mm < 400 )
                            {
    
                                    GPIO_ResetBits(GPIOB,GPIO_Pin_10);
                                    Delay_ms(100);
                                    GPIO_SetBits(GPIOB,GPIO_Pin_10);
                                
                                    back();
                                    Delay_ms (300);
                                    stop();
                                
                                    Angle=50;        //left
                                    OLED_ShowNum(2, 14, Angle, 3);
                                    Servo_SetAngle(Angle);
                                    Delay_ms (500);
                                    Distance_mm=sonar_mm();                                    
                            }    
                        }        


                                                
                        if(Angle == 50)
                        {
                            if(  Distance_mm > 400)
                            {
                                run_left();
                                Delay_ms(150);
                                stop();
                                
                                Angle=90;
                                OLED_ShowNum(2, 14, Angle, 3);
                                Servo_SetAngle(Angle);                                        
                            }
                        }                        
                        if(Angle == 50)
                        {
                            if(  Distance_mm < 400)
                            {
                                    Angle=130;
                                    OLED_ShowNum(2, 14, Angle, 3);
                                    Servo_SetAngle(Angle);
                                    Delay_ms (500);
                                
                                    Distance_mm=sonar_mm();    
                                    
                                    GPIO_ResetBits(GPIOB,GPIO_Pin_10);
                                    Delay_ms(100);
                                    GPIO_SetBits(GPIOB,GPIO_Pin_10);                                        
                            }
                        }

                                
                        
                        if(Angle == 130)
                        {
                            if(Distance_mm >400)
                            {

                                run_right();
                                Delay_ms(150);
                                stop();
                                
                                Angle=90;
                                OLED_ShowNum(2, 14, Angle, 3);
                                Servo_SetAngle(Angle);
                                Delay_ms (500);                                
                            }
                        }                        
                        if(Angle == 130)
                        {
                            if(Distance_mm <400)
                            {

                                    GPIO_ResetBits(GPIOB,GPIO_Pin_10);
                                    Delay_ms(100);
                                    GPIO_SetBits(GPIOB,GPIO_Pin_10);    
                                    
                                    back();
                                    Delay_ms(500);
                                    Angle=90;    
                                    OLED_ShowNum(2, 14, Angle, 3);
                                    Servo_SetAngle(Angle);    
                                    Delay_ms (500);
                            }
                        }

                        

                        OLED_ShowNum(2, 14, Angle, 3);
                    }
                }
            }
            
        

            OLED_ShowNum(2, 14, Angle, 3);
    }
}
PUTCHAR_PROTOTYPE
{
  /* Place your implementation of fputc here */
  /* e.g. write a character to the USART */
 USART_SendData(USART1, (uint8_t) ch);

  /* Ñ­»·µÈ´ýÖ±µ½·¢ËͽáÊø*/
  while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)
  {}

  return ch;
}

延时函数.c


#include "stm32f10x.h"

/**
  * @brief  微秒级延时
  * @param  xus 延时时长，范围：0~233015
  * @retval 无
  */
void Delay_us(uint32_t xus)
{
    SysTick->LOAD = 72 * xus;                //设置定时器重装值
    SysTick->VAL = 0x00;                    //清空当前计数值
    SysTick->CTRL = 0x00000005;                //设置时钟源为HCLK，启动定时器
    while(!(SysTick->CTRL & 0x00010000));    //等待计数到0
    SysTick->CTRL = 0x00000004;                //关闭定时器
}

/**
  * @brief  毫秒级延时
  * @param  xms 延时时长，范围：0~4294967295
  * @retval 无
  */
void Delay_ms(uint32_t xms)
{
    while(xms--)
    {
        Delay_us(1000);
    }
}
 
/**
  * @brief  秒级延时
  * @param  xs 延时时长，范围：0~4294967295
  * @retval 无
  */
void Delay_s(uint32_t xs)
{
    while(xs--)
    {
        Delay_ms(1000);
    }
}

延时函数.h


#ifndef __DELAY_H
#define __DELAY_H

void Delay_us(uint32_t us);
void Delay_ms(uint32_t ms);
void Delay_s(uint32_t s);

#endif

中断.c


#include "stm32f10x.h"                  // Device header

void Timer_Init(void)
{
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);        //启用TIM3时钟
                                                                // https://blog.zeruns.tech
    TIM_InternalClockConfig(TIM3);                                //设置TIM3使用内部时钟
    
    TIM_TimeBaseInitTypeDef TIM_TimeBaseInitStructure;            //定义结构体，配置定时器
    TIM_TimeBaseInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;    //设置1分频（不分频）
    TIM_TimeBaseInitStructure.TIM_CounterMode = TIM_CounterMode_Up;    //设置计数模式为向上计数
    TIM_TimeBaseInitStructure.TIM_Period = 10 - 1;            //设置最大计数值，达到最大值触发更新事件，因为从0开始计数，所以计数10次是10-1,每10微秒触发一次
    TIM_TimeBaseInitStructure.TIM_Prescaler = 72 - 1;            //设置时钟预分频，72-1就是每 时钟频率(72Mhz)/72=1000000 个时钟周期计数器加1,每1微秒+1
    TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;        //重复计数器（高级定时器才有，所以设置0）
    TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStructure);            //初始化TIM3定时器
    
    TIM_ClearFlag(TIM3, TIM_FLAG_Update);            //清除更新中断标志位
    TIM_ITConfig(TIM3, TIM_IT_Update, ENABLE);        //开启更新中断
    
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);                //设置中断优先级分组
    
    NVIC_InitTypeDef NVIC_InitStructure;                        //定义结构体，配置中断优先级
    NVIC_InitStructure.NVIC_IRQChannel = TIM3_IRQn;                //指定中断通道
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                //中断使能
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;    //设置抢占优先级
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;            //设置响应优先级
    NVIC_Init(&NVIC_InitStructure);
    
    TIM_Cmd(TIM3, ENABLE);                            //开启定时器
}

/*
void TIM3_IRQHandler(void)            //更新中断函数
{
    if (TIM_GetITStatus(TIM3, TIM_IT_Update) == SET)        //获取TIM3定时器的更新中断标志位
    {
        
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);            //清除更新中断标志位
    }
}*/

中断.h


#ifndef __TIMER_H
#define __TIMER_H

void Timer_Init(void);

#endif

按键.c


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

void Key_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_1 | GPIO_Pin_9| GPIO_Pin_8;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    

    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB,&GPIO_InitStructure);
    
    GPIO_SetBits(GPIOB,GPIO_Pin_10);
        
}

uint8_t Key_GetNum(void)
{
    uint8_t KeyNum = 0;
    if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_8) == 0)
    {
        Delay_ms(20);
        while (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_8) == 0);
        Delay_ms(20);
        KeyNum = 1;
    }
    if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 0)
    {
        Delay_ms(20);
        while (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_1) == 0);
        Delay_ms(20);
        KeyNum = 2;
    }
    if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_9) == 0)
    {
        Delay_ms(20);
        while (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_9) == 0);
        Delay_ms(20);
        KeyNum = 3;
    }
    
    return KeyNum;
}

按键.h


#ifndef __KEY_H
#define __KEY_H

void Key_Init(void);
uint8_t Key_GetNum(void);

#endif

pwm舵机.c


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


//void PWM_Init1(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_0;        //GPIO_Pin_15;
//    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 = 720 - 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 = high;
//    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
//    TIM_OCInitStructure.TIM_Pulse = 0;        //CCR
//    TIM_OC1Init(TIM2, &TIM_OCInitStructure);

//    TIM_Cmd(TIM2, ENABLE);
//}

//void PWM_SetCompare1(uint16_t Compare1)
//{
//    TIM_SetCompare1(TIM2, Compare1);
//}

//void PWM_SetPrescaler1(uint16_t Prescaler1)
//{
//    TIM_PrescalerConfig(TIM2, Prescaler1, TIM_PSCReloadMode_Immediate);
//}






//void PWM_Init4(void)//ÓÒÇ°ÂÖ×Ó
//{
//    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE);
//    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
//    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    GPIO_PinRemapConfig(GPIO_PartialRemap1_TIM2, ENABLE);
    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);
//    
//    GPIO_InitTypeDef GPIO_InitStructure;
//    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
//    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;        //GPIO_Pin_15;
//    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
//    GPIO_Init(GPIOA, &GPIO_InitStructure);
//    
//    TIM_InternalClockConfig(TIM3);
//    
//    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 = 720 - 1;        //PSC
//    TIM_TimeBaseInitStructure.TIM_RepetitionCounter = 0;
//    TIM_TimeBaseInit(TIM3, &TIM_TimeBaseInitStructure);
//    
//    TIM_OCInitTypeDef TIM_OCInitStructure;
//    TIM_OCStructInit(&TIM_OCInitStructure);
//    TIM_OCInitStructure.TIM_OCMode = TIM_OCMode_PWM1 ;
//    TIM_OCInitStructure.TIM_OCPolarity = TIM_OCNPolarity_High  ;
//    TIM_OCInitStructure.TIM_OutputState = TIM_OutputState_Enable;
//    TIM_OCInitStructure.TIM_Pulse = 0;        //CCR
//    TIM_OC1Init(TIM3, &TIM_OCInitStructure);
//    
//    TIM_Cmd(TIM3, ENABLE);
//}

//void PWM_SetCompare4(uint16_t Compare4)
//{
//    TIM_SetCompare1(TIM3, Compare4);
//}

//void PWM_SetPrescaler4(uint16_t Prescaler4)
//{
//    TIM_PrescalerConfig(TIM3, Prescaler4, TIM_PSCReloadMode_Immediate);
//}










void PWMSG_Init(void)
{
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
//    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);     ´ò¿ªafilÄÚ²¿Ê±ÖÓ
//    GPIO_PinRemapConfig(GPIO_PartialRemap1_TIM2, ENABLE);    ÖØж¨ÒåÒý½ÅÍâÉè
//    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE); ½â³ýÔ­±¾a15£¬b3£¬b4µÄµ÷ÊÔ¹¦ÄÜ
    
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = 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 = 20000 - 1;        //ARR
    TIM_TimeBaseInitStructure.TIM_Prescaler = 72 - 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_OC2Init(TIM2, &TIM_OCInitStructure);
    //TIM_OC1InitÓõÄÊÇgpioµÄa0ͨµÀ£¬ÕâÀïÓõÄÊÇa1ËùÒÔ¿ªÆôµÄÊÇoc2£¬ÒÔ´ËÀàÍÆ£¬È»ºóÏÂÃæµÄcompare¶ÔÓ¦µÄÒ²ÊÇocÒ»ÑùµÄ
    TIM_Cmd(TIM2, ENABLE);
}

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

pwm舵机.h


#ifndef __PWM_H
#define __PWM_H

//#define high TIM_OCPolarity_High 
//#define low TIM_OCPolarity_Low 

//void PWM_Init1(void);//×óÇ°ÂÖ×Ó
//void PWM_SetCompare1(uint16_t Compare1);
//void PWM_SetPrescaler1(uint16_t Prescaler1);

//void PWM_Init4(void);//ÓÒÇ°ÂÖ×Ó
//void PWM_SetCompare4(uint16_t Compare4);
//void PWM_SetPrescaler4(uint16_t Prescaler4);

void PWMSG_Init(void);
void PWM_SetCompare2(uint16_t Compare);

#endif

电机.c


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

//01  right_behind
//23  right_back
//67  left_behind
//45  left_back

void Motor_Init(void)
{
//    PWM_Init1();//×óÇ°ÂÖ×Ó


//    PWM_Init4();//ÓÒÇ°ÂÖ×Ó

    
    
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7| GPIO_Pin_6;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14 |GPIO_Pin_0|GPIO_Pin_11;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
    
//    PWM_SetPrescaler4(720 - 1);
//    PWM_SetPrescaler1(720 - 1);//a0
}



//ºóÍ˵Äʱºò¸ø0£¬Ô½Ð¡Ô½ÓÐËÙ¶È
//Ç°½øµÄʱºò¸ø100£¬Ô½´óÔ½ÓÐËÙ¶È

//100,100
void run(void)//Ö±×ß
{
    GPIO_ResetBits(GPIOA,  GPIO_Pin_3| GPIO_Pin_5| GPIO_Pin_7);
    GPIO_ResetBits(GPIOB,  GPIO_Pin_11);
//    PWM_SetCompare1(right);
//    PWM_SetCompare4(left);
    GPIO_SetBits (GPIOA,GPIO_Pin_2);
    GPIO_SetBits (GPIOA,GPIO_Pin_4);
    GPIO_SetBits (GPIOB,GPIO_Pin_0);
    GPIO_SetBits (GPIOA,GPIO_Pin_6);
    
    
    GPIO_SetBits (GPIOB,GPIO_Pin_14);
}
//0,0
void back(void)//ºóÍË
{
    GPIO_SetBits(GPIOA,  GPIO_Pin_3| GPIO_Pin_5| GPIO_Pin_7);
    GPIO_SetBits(GPIOB,  GPIO_Pin_11);
//    PWM_SetCompare1(right);
//    PWM_SetCompare4(left);
    GPIO_ResetBits (GPIOA,GPIO_Pin_2);
    GPIO_ResetBits (GPIOA,GPIO_Pin_4);
    GPIO_ResetBits (GPIOB,GPIO_Pin_0);
    GPIO_ResetBits (GPIOA,GPIO_Pin_6);
    
    
    GPIO_SetBits (GPIOB,GPIO_Pin_14);
}
//0,100
void run_right(void)//×óÇ°
{
    GPIO_ResetBits(GPIOA,   GPIO_Pin_5| GPIO_Pin_7);

//    PWM_SetCompare1(right);
//    PWM_SetCompare4(left);

    GPIO_SetBits (GPIOA,GPIO_Pin_4);
    GPIO_SetBits (GPIOA,GPIO_Pin_6);
    
    
    GPIO_SetBits (GPIOB,GPIO_Pin_14);
}
//0,0
void back_right(void)//×óºó
{
    GPIO_SetBits(GPIOA,   GPIO_Pin_5| GPIO_Pin_7);

//    PWM_SetCompare1(right);
//    PWM_SetCompare4(left);

    GPIO_ResetBits (GPIOA,GPIO_Pin_4);
    GPIO_ResetBits (GPIOA,GPIO_Pin_6);
    
    
    GPIO_SetBits (GPIOB,GPIO_Pin_14);
}
//100,0
void run_left(void)//ÓÒÇ°
{
    GPIO_ResetBits(GPIOA,  GPIO_Pin_3);
    GPIO_ResetBits(GPIOB,  GPIO_Pin_11);
//    PWM_SetCompare1(right);
//    PWM_SetCompare4(left);
    GPIO_SetBits (GPIOA,GPIO_Pin_2);
    GPIO_SetBits (GPIOB,GPIO_Pin_0);
    
    
    GPIO_SetBits (GPIOB,GPIO_Pin_14);
}
//0,0
void back_left(void)//ÓÒºó
{
    GPIO_SetBits(GPIOA,  GPIO_Pin_3);
    GPIO_SetBits(GPIOB,  GPIO_Pin_11);
//    PWM_SetCompare1(right);
//    PWM_SetCompare4(left);
    GPIO_ResetBits (GPIOA,GPIO_Pin_2);
    GPIO_ResetBits (GPIOB,GPIO_Pin_0);
    
    
    GPIO_SetBits (GPIOB,GPIO_Pin_14);
}

void stop(void)//Í£Ö¹
{
    GPIO_ResetBits (GPIOB,GPIO_Pin_14);
}

电机.h


#ifndef __MOTOR_H__
#define __MOTOR_H__

//01  right_behind
//23  right_back
//67  left_behind
//45  left_back

void Motor_Init(void);
void run(void);//Ö±×ß100100
void back(void);//ºóÍË00
void run_right(void);//×óÇ°//0,100
void back_right(void);//×óºó//0,0
void run_left(void);//ÓÒÇ°//100,0
void back_left(void);//ÓÒºó//0,0
void stop(void);//Í£Ö¹

#endif

超声波.c


#include "stm32f10x.h"
#include "Delay.h"

/*
具体使用说明请到我博客：// https://blog.zeruns.tech
*/

#define Echo GPIO_Pin_6        //HC-SR04模块的Echo脚接GPIOB6
#define Trig GPIO_Pin_5        //HC-SR04模块的Trig脚接GPIOB5

uint64_t time=0;            //声明变量，用来计时
uint64_t time_end=0;        //声明变量，存储回波信号时间

void HC_SR04_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);    //启用GPIOB的外设时钟    
    GPIO_InitTypeDef GPIO_InitStructure;                    //定义结构体
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;        //设置GPIO口为推挽输出
    GPIO_InitStructure.GPIO_Pin = Trig;                        //设置GPIO口5
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;        //设置GPIO口速度50Mhz
    GPIO_Init(GPIOB,&GPIO_InitStructure);                    //初始化GPIOB
    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;            //设置GPIO口为下拉输入模式
    GPIO_InitStructure.GPIO_Pin = Echo;                        //设置GPIO口6
    GPIO_Init(GPIOB,&GPIO_InitStructure);                    //初始化GPIOB
    GPIO_WriteBit(GPIOB,GPIO_Pin_5,0);                        //输出低电平
    Delay_us(15);                                            //延时15微秒
}

int16_t sonar_mm(void)                                    //测距并返回单位为毫米的距离结果
{
    uint32_t Distance,Distance_mm = 0;
    GPIO_WriteBit(GPIOB,Trig,1);                        //输出高电平
    Delay_us(15);                                        //延时15微秒
    GPIO_WriteBit(GPIOB,Trig,0);                        //输出低电平
    while(GPIO_ReadInputDataBit(GPIOB,Echo)==0);        //等待低电平结束
    time=0;                                                //计时清零
    while(GPIO_ReadInputDataBit(GPIOB,Echo)==1);        //等待高电平结束
    time_end=time;                                        //记录结束时的时间
    if(time_end/100<38)                                    //判断是否小于38毫秒，大于38毫秒的就是超时，直接调到下面返回0
    {
        Distance=(time_end*346)/2;                        //计算距离，25°C空气中的音速为346m/s
        Distance_mm=Distance/100;                        //因为上面的time_end的单位是10微秒，所以要得出单位为毫米的距离结果，还得除以100
    }
    return Distance_mm;                                    //返回测距结果
}

float sonar(void)                                        //测距并返回单位为米的距离结果
{
    uint32_t Distance,Distance_mm = 0;
    float Distance_m=0;
    GPIO_WriteBit(GPIOB,Trig,1);                    //输出高电平
    Delay_us(15);
    GPIO_WriteBit(GPIOB,Trig,0);                    //输出低电平
    while(GPIO_ReadInputDataBit(GPIOB,Echo)==0);
    time=0;
    while(GPIO_ReadInputDataBit(GPIOB,Echo)==1);
    time_end=time;
    if(time_end/100<38)
    {
        Distance=(time_end*346)/2;
        Distance_mm=Distance/100;
        Distance_m=Distance_mm/1000;
    }
    return Distance_m;
}

void TIM3_IRQHandler(void)            //更新中断函数，用来计时，每10微秒变量time加1
{                                    // https://blog.zeruns.tech
    if (TIM_GetITStatus(TIM3, TIM_IT_Update) == SET)        //获取TIM3定时器的更新中断标志位
    {
        time++;
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);            //清除更新中断标志位
    }
}

超声波.h


#ifndef __HCSR04_H
#define __HCSR04_H

void HC_SR04_Init(void);
int16_t sonar_mm(void);
float sonar(void);

#endif

oled的三个文件


#include "stm32f10x.h"
#include "OLED_Font.h"

/*引脚配置*/
#define OLED_SCL GPIO_Pin_12    //OLED屏的SCL脚接GPIOB12
#define OLED_SDA GPIO_Pin_13    //OLED屏的SDA脚接GPIOB13
#define OLED_W_SCL(x)        GPIO_WriteBit(GPIOB, OLED_SCL, (BitAction)(x))
#define OLED_W_SDA(x)        GPIO_WriteBit(GPIOB, OLED_SDA, (BitAction)(x))

/*引脚初始化*/
void OLED_I2C_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
    
    GPIO_InitTypeDef GPIO_InitStructure;
     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Pin = OLED_SCL;
     GPIO_Init(GPIOB, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Pin = OLED_SDA;
     GPIO_Init(GPIOB, &GPIO_InitStructure);
    
    OLED_W_SCL(1);
    OLED_W_SDA(1);
}

// https://blog.zeruns.tech

/**
  * @brief  I2C开始
  * @param  无
  * @retval 无
  */
void OLED_I2C_Start(void)
{
    OLED_W_SDA(1);
    OLED_W_SCL(1);
    OLED_W_SDA(0);
    OLED_W_SCL(0);
}

/**
  * @brief  I2C停止
  * @param  无
  * @retval 无
  */
void OLED_I2C_Stop(void)
{
    OLED_W_SDA(0);
    OLED_W_SCL(1);
    OLED_W_SDA(1);
}

/**
  * @brief  I2C发送一个字节
  * @param  Byte 要发送的一个字节
  * @retval 无
  */
void OLED_I2C_SendByte(uint8_t Byte)
{
    uint8_t i;
    for (i = 0; i < 8; i++)
    {
        OLED_W_SDA(Byte & (0x80 >> i));
        OLED_W_SCL(1);
        OLED_W_SCL(0);
    }
    OLED_W_SCL(1);    //额外的一个时钟，不处理应答信号
    OLED_W_SCL(0);
}

/**
  * @brief  OLED写命令
  * @param  Command 要写入的命令
  * @retval 无
  */
void OLED_WriteCommand(uint8_t Command)
{
    OLED_I2C_Start();
    OLED_I2C_SendByte(0x78);        //从机地址
    OLED_I2C_SendByte(0x00);        //写命令
    OLED_I2C_SendByte(Command); 
    OLED_I2C_Stop();
}

/**
  * @brief  OLED写数据
  * @param  Data 要写入的数据
  * @retval 无
  */
void OLED_WriteData(uint8_t Data)
{
    OLED_I2C_Start();
    OLED_I2C_SendByte(0x78);        //从机地址
    OLED_I2C_SendByte(0x40);        //写数据
    OLED_I2C_SendByte(Data);
    OLED_I2C_Stop();
}

/**
  * @brief  OLED设置光标位置
  * @param  Y 以左上角为原点，向下方向的坐标，范围：0~7
  * @param  X 以左上角为原点，向右方向的坐标，范围：0~127
  * @retval 无
  */
void OLED_SetCursor(uint8_t Y, uint8_t X)
{
    OLED_WriteCommand(0xB0 | Y);                    //设置Y位置
    OLED_WriteCommand(0x10 | ((X & 0xF0) >> 4));    //设置X位置低4位
    OLED_WriteCommand(0x00 | (X & 0x0F));            //设置X位置高4位
}

/**
  * @brief  OLED清屏
  * @param  无
  * @retval 无
  */
void OLED_Clear(void)
{  
    uint8_t i, j;
    for (j = 0; j < 8; j++)
    {
        OLED_SetCursor(j, 0);
        for(i = 0; i < 128; i++)
        {
            OLED_WriteData(0x00);
        }
    }
}

/**
  * @brief  OLED部分清屏
  * @param  Line 行位置，范围：1~4
  * @param  start 列开始位置，范围：1~16
  * @param  end 列开始位置，范围：1~16
  * @retval 无
  */
void OLED_Clear_Part(uint8_t Line, uint8_t start, uint8_t end)
{  
    uint8_t i,Column;
    for(Column = start; Column <= end; Column++)
    {
        OLED_SetCursor((Line - 1) * 2, (Column - 1) * 8);        //设置光标位置在上半部分
        for (i = 0; i < 8; i++)
        {
            OLED_WriteData(0x00);            //显示上半部分内容
        }
        OLED_SetCursor((Line - 1) * 2 + 1, (Column - 1) * 8);    //设置光标位置在下半部分
        for (i = 0; i < 8; i++)
        {
            OLED_WriteData(0x00);        //显示下半部分内容
        }
    }
}


/**
  * @brief  OLED显示一个字符
  * @param  Line 行位置，范围：1~4
  * @param  Column 列位置，范围：1~16
  * @param  Char 要显示的一个字符，范围：ASCII可见字符
  * @retval 无
  */
void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char)
{          
    uint8_t i;
    OLED_SetCursor((Line - 1) * 2, (Column - 1) * 8);        //设置光标位置在上半部分
    for (i = 0; i < 8; i++)
    {
        OLED_WriteData(OLED_F8x16[Char - ' '][i]);            //显示上半部分内容
    }
    OLED_SetCursor((Line - 1) * 2 + 1, (Column - 1) * 8);    //设置光标位置在下半部分
    for (i = 0; i < 8; i++)
    {
        OLED_WriteData(OLED_F8x16[Char - ' '][i + 8]);        //显示下半部分内容
    }
}

/**
  * @brief  OLED显示字符串
  * @param  Line 起始行位置，范围：1~4
  * @param  Column 起始列位置，范围：1~16
  * @param  String 要显示的字符串，范围：ASCII可见字符
  * @retval 无
  */
void OLED_ShowString(uint8_t Line, uint8_t Column, char *String)
{
    uint8_t i;
    for (i = 0; String[i] != '\0'; i++)
    {
        OLED_ShowChar(Line, Column + i, String[i]);
    }
}

/**
  * @brief  OLED次方函数
  * @retval 返回值等于X的Y次方
  */
uint32_t OLED_Pow(uint32_t X, uint32_t Y)
{
    uint32_t Result = 1;
    while (Y--)
    {
        Result *= X;
    }
    return Result;
}

/**
  * @brief  OLED显示数字（十进制，正数）
  * @param  Line 起始行位置，范围：1~4
  * @param  Column 起始列位置，范围：1~16
  * @param  Number 要显示的数字，范围：0~4294967295
  * @param  Length 要显示数字的长度，范围：1~10
  * @retval 无
  */
void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
    uint8_t i;
    for (i = 0; i < Length; i++)                            
    {
        OLED_ShowChar(Line, Column + i, Number / OLED_Pow(10, Length - i - 1) % 10 + '0');
    }
}

/**
  * @brief  OLED显示数字（十进制，带符号数）
  * @param  Line 起始行位置，范围：1~4
  * @param  Column 起始列位置，范围：1~16
  * @param  Number 要显示的数字，范围：-2147483648~2147483647
  * @param  Length 要显示数字的长度，范围：1~10
  * @retval 无
  */
void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length)
{
    uint8_t i;
    uint32_t Number1;
    if (Number >= 0)
    {
        OLED_ShowChar(Line, Column, '+');
        Number1 = Number;
    }
    else
    {
        OLED_ShowChar(Line, Column, '-');
        Number1 = -Number;
    }
    for (i = 0; i < Length; i++)                            
    {
        OLED_ShowChar(Line, Column + i + 1, Number1 / OLED_Pow(10, Length - i - 1) % 10 + '0');
    }
}

/**
  * @brief  OLED显示数字（十六进制，正数）
  * @param  Line 起始行位置，范围：1~4
  * @param  Column 起始列位置，范围：1~16
  * @param  Number 要显示的数字，范围：0~0xFFFFFFFF
  * @param  Length 要显示数字的长度，范围：1~8
  * @retval 无
  */
void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
    uint8_t i, SingleNumber;
    for (i = 0; i < Length; i++)                            
    {
        SingleNumber = Number / OLED_Pow(16, Length - i - 1) % 16;
        if (SingleNumber < 10)
        {
            OLED_ShowChar(Line, Column + i, SingleNumber + '0');
        }
        else
        {
            OLED_ShowChar(Line, Column + i, SingleNumber - 10 + 'A');
        }
    }
}

/**
  * @brief  OLED显示数字（二进制，正数）
  * @param  Line 起始行位置，范围：1~4
  * @param  Column 起始列位置，范围：1~16
  * @param  Number 要显示的数字，范围：0~1111 1111 1111 1111
  * @param  Length 要显示数字的长度，范围：1~16
  * @retval 无
  */
void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length)
{
    uint8_t i;
    for (i = 0; i < Length; i++)                            
    {
        OLED_ShowChar(Line, Column + i, Number / OLED_Pow(2, Length - i - 1) % 2 + '0');
    }
}

/**
  * @brief  OLED初始化
  * @param  无
  * @retval 无
  */
void OLED_Init(void)
{
    uint32_t i, j;
    
    for (i = 0; i < 1000; i++)            //上电延时
    {
        for (j = 0; j < 1000; j++);
    }
    
    OLED_I2C_Init();            //端口初始化
    
    OLED_WriteCommand(0xAE);    //关闭显示
    
    OLED_WriteCommand(0xD5);    //设置显示时钟分频比/振荡器频率
    OLED_WriteCommand(0x80);
    
    OLED_WriteCommand(0xA8);    //设置多路复用率
    OLED_WriteCommand(0x3F);
    
    OLED_WriteCommand(0xD3);    //设置显示偏移
    OLED_WriteCommand(0x00);
    
    OLED_WriteCommand(0x40);    //设置显示开始行
    
    OLED_WriteCommand(0xA1);    //设置左右方向，0xA1正常 0xA0左右反置
    
    OLED_WriteCommand(0xC8);    //设置上下方向，0xC8正常 0xC0上下反置

    OLED_WriteCommand(0xDA);    //设置COM引脚硬件配置
    OLED_WriteCommand(0x12);
    
    OLED_WriteCommand(0x81);    //设置对比度控制
    OLED_WriteCommand(0xCF);

    OLED_WriteCommand(0xD9);    //设置预充电周期
    OLED_WriteCommand(0xF1);

    OLED_WriteCommand(0xDB);    //设置VCOMH取消选择级别
    OLED_WriteCommand(0x30);

    OLED_WriteCommand(0xA4);    //设置整个显示打开/关闭

    OLED_WriteCommand(0xA6);    //设置正常/倒转显示

    OLED_WriteCommand(0x8D);    //设置充电泵
    OLED_WriteCommand(0x14);

    OLED_WriteCommand(0xAF);    //开启显示
        
    OLED_Clear();                //OLED清屏
}

#ifndef __OLED_H
#define __OLED_H

void OLED_Init(void);
void OLED_Clear(void);
void OLED_ShowChar(uint8_t Line, uint8_t Column, char Char);
void OLED_ShowString(uint8_t Line, uint8_t Column, char *String);
void OLED_ShowNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
void OLED_ShowSignedNum(uint8_t Line, uint8_t Column, int32_t Number, uint8_t Length);
void OLED_ShowHexNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
void OLED_ShowBinNum(uint8_t Line, uint8_t Column, uint32_t Number, uint8_t Length);
void OLED_Clear_Part(uint8_t Line, uint8_t start, uint8_t end);

#endif


#ifndef __OLED_FONT_H
#define __OLED_FONT_H

/*OLED字模库，宽8像素，高16像素*/
const uint8_t OLED_F8x16[][16]=
{
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//  0
    
    0x00,0x00,0x00,0xF8,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x33,0x30,0x00,0x00,0x00,//! 1
    
    0x00,0x10,0x0C,0x06,0x10,0x0C,0x06,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//" 2
    
    0x40,0xC0,0x78,0x40,0xC0,0x78,0x40,0x00,
    0x04,0x3F,0x04,0x04,0x3F,0x04,0x04,0x00,//# 3
    
    0x00,0x70,0x88,0xFC,0x08,0x30,0x00,0x00,
    0x00,0x18,0x20,0xFF,0x21,0x1E,0x00,0x00,//$ 4
    
    0xF0,0x08,0xF0,0x00,0xE0,0x18,0x00,0x00,
    0x00,0x21,0x1C,0x03,0x1E,0x21,0x1E,0x00,//% 5
    
    0x00,0xF0,0x08,0x88,0x70,0x00,0x00,0x00,
    0x1E,0x21,0x23,0x24,0x19,0x27,0x21,0x10,//& 6
    
    0x10,0x16,0x0E,0x00,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//' 7
    
    0x00,0x00,0x00,0xE0,0x18,0x04,0x02,0x00,
    0x00,0x00,0x00,0x07,0x18,0x20,0x40,0x00,//( 8
    
    0x00,0x02,0x04,0x18,0xE0,0x00,0x00,0x00,
    0x00,0x40,0x20,0x18,0x07,0x00,0x00,0x00,//) 9
    
    0x40,0x40,0x80,0xF0,0x80,0x40,0x40,0x00,
    0x02,0x02,0x01,0x0F,0x01,0x02,0x02,0x00,//* 10
    
    0x00,0x00,0x00,0xF0,0x00,0x00,0x00,0x00,
    0x01,0x01,0x01,0x1F,0x01,0x01,0x01,0x00,//+ 11
    
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x80,0xB0,0x70,0x00,0x00,0x00,0x00,0x00,//, 12
    
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x01,0x01,0x01,0x01,0x01,0x01,0x01,//- 13
    
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x00,0x30,0x30,0x00,0x00,0x00,0x00,0x00,//. 14
    
    0x00,0x00,0x00,0x00,0x80,0x60,0x18,0x04,
    0x00,0x60,0x18,0x06,0x01,0x00,0x00,0x00,/// 15
    
    0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,
    0x00,0x0F,0x10,0x20,0x20,0x10,0x0F,0x00,//0 16
    
    0x00,0x10,0x10,0xF8,0x00,0x00,0x00,0x00,
    0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//1 17
    
    0x00,0x70,0x08,0x08,0x08,0x88,0x70,0x00,
    0x00,0x30,0x28,0x24,0x22,0x21,0x30,0x00,//2 18
    
    0x00,0x30,0x08,0x88,0x88,0x48,0x30,0x00,
    0x00,0x18,0x20,0x20,0x20,0x11,0x0E,0x00,//3 19
    
    0x00,0x00,0xC0,0x20,0x10,0xF8,0x00,0x00,
    0x00,0x07,0x04,0x24,0x24,0x3F,0x24,0x00,//4 20
    
    0x00,0xF8,0x08,0x88,0x88,0x08,0x08,0x00,
    0x00,0x19,0x21,0x20,0x20,0x11,0x0E,0x00,//5 21
    
    0x00,0xE0,0x10,0x88,0x88,0x18,0x00,0x00,
    0x00,0x0F,0x11,0x20,0x20,0x11,0x0E,0x00,//6 22
    
    0x00,0x38,0x08,0x08,0xC8,0x38,0x08,0x00,
    0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x00,//7 23
    
    0x00,0x70,0x88,0x08,0x08,0x88,0x70,0x00,
    0x00,0x1C,0x22,0x21,0x21,0x22,0x1C,0x00,//8 24
    
    0x00,0xE0,0x10,0x08,0x08,0x10,0xE0,0x00,
    0x00,0x00,0x31,0x22,0x22,0x11,0x0F,0x00,//9 25
    
    0x00,0x00,0x00,0xC0,0xC0,0x00,0x00,0x00,
    0x00,0x00,0x00,0x30,0x30,0x00,0x00,0x00,//: 26
    
    0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,
    0x00,0x00,0x80,0x60,0x00,0x00,0x00,0x00,//; 27
    
    0x00,0x00,0x80,0x40,0x20,0x10,0x08,0x00,
    0x00,0x01,0x02,0x04,0x08,0x10,0x20,0x00,//< 28
    
    0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x00,
    0x04,0x04,0x04,0x04,0x04,0x04,0x04,0x00,//= 29
    
    0x00,0x08,0x10,0x20,0x40,0x80,0x00,0x00,
    0x00,0x20,0x10,0x08,0x04,0x02,0x01,0x00,//> 30
    
    0x00,0x70,0x48,0x08,0x08,0x08,0xF0,0x00,
    0x00,0x00,0x00,0x30,0x36,0x01,0x00,0x00,//? 31
    
    0xC0,0x30,0xC8,0x28,0xE8,0x10,0xE0,0x00,
    0x07,0x18,0x27,0x24,0x23,0x14,0x0B,0x00,//@ 32
    
    0x00,0x00,0xC0,0x38,0xE0,0x00,0x00,0x00,
    0x20,0x3C,0x23,0x02,0x02,0x27,0x38,0x20,//A 33
    
    0x08,0xF8,0x88,0x88,0x88,0x70,0x00,0x00,
    0x20,0x3F,0x20,0x20,0x20,0x11,0x0E,0x00,//B 34
    
    0xC0,0x30,0x08,0x08,0x08,0x08,0x38,0x00,
    0x07,0x18,0x20,0x20,0x20,0x10,0x08,0x00,//C 35
    
    0x08,0xF8,0x08,0x08,0x08,0x10,0xE0,0x00,
    0x20,0x3F,0x20,0x20,0x20,0x10,0x0F,0x00,//D 36
    
    0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,
    0x20,0x3F,0x20,0x20,0x23,0x20,0x18,0x00,//E 37
    
    0x08,0xF8,0x88,0x88,0xE8,0x08,0x10,0x00,
    0x20,0x3F,0x20,0x00,0x03,0x00,0x00,0x00,//F 38
    
    0xC0,0x30,0x08,0x08,0x08,0x38,0x00,0x00,
    0x07,0x18,0x20,0x20,0x22,0x1E,0x02,0x00,//G 39
    
    0x08,0xF8,0x08,0x00,0x00,0x08,0xF8,0x08,
    0x20,0x3F,0x21,0x01,0x01,0x21,0x3F,0x20,//H 40
    
    0x00,0x08,0x08,0xF8,0x08,0x08,0x00,0x00,
    0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//I 41
    
    0x00,0x00,0x08,0x08,0xF8,0x08,0x08,0x00,
    0xC0,0x80,0x80,0x80,0x7F,0x00,0x00,0x00,//J 42
    
    0x08,0xF8,0x88,0xC0,0x28,0x18,0x08,0x00,
    0x20,0x3F,0x20,0x01,0x26,0x38,0x20,0x00,//K 43
    
    0x08,0xF8,0x08,0x00,0x00,0x00,0x00,0x00,
    0x20,0x3F,0x20,0x20,0x20,0x20,0x30,0x00,//L 44
    
    0x08,0xF8,0xF8,0x00,0xF8,0xF8,0x08,0x00,
    0x20,0x3F,0x00,0x3F,0x00,0x3F,0x20,0x00,//M 45
    
    0x08,0xF8,0x30,0xC0,0x00,0x08,0xF8,0x08,
    0x20,0x3F,0x20,0x00,0x07,0x18,0x3F,0x00,//N 46
    
    0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,
    0x0F,0x10,0x20,0x20,0x20,0x10,0x0F,0x00,//O 47
    
    0x08,0xF8,0x08,0x08,0x08,0x08,0xF0,0x00,
    0x20,0x3F,0x21,0x01,0x01,0x01,0x00,0x00,//P 48
    
    0xE0,0x10,0x08,0x08,0x08,0x10,0xE0,0x00,
    0x0F,0x18,0x24,0x24,0x38,0x50,0x4F,0x00,//Q 49
    
    0x08,0xF8,0x88,0x88,0x88,0x88,0x70,0x00,
    0x20,0x3F,0x20,0x00,0x03,0x0C,0x30,0x20,//R 50
    
    0x00,0x70,0x88,0x08,0x08,0x08,0x38,0x00,
    0x00,0x38,0x20,0x21,0x21,0x22,0x1C,0x00,//S 51
    
    0x18,0x08,0x08,0xF8,0x08,0x08,0x18,0x00,
    0x00,0x00,0x20,0x3F,0x20,0x00,0x00,0x00,//T 52
    
    0x08,0xF8,0x08,0x00,0x00,0x08,0xF8,0x08,
    0x00,0x1F,0x20,0x20,0x20,0x20,0x1F,0x00,//U 53
    
    0x08,0x78,0x88,0x00,0x00,0xC8,0x38,0x08,
    0x00,0x00,0x07,0x38,0x0E,0x01,0x00,0x00,//V 54
    
    0xF8,0x08,0x00,0xF8,0x00,0x08,0xF8,0x00,
    0x03,0x3C,0x07,0x00,0x07,0x3C,0x03,0x00,//W 55
    
    0x08,0x18,0x68,0x80,0x80,0x68,0x18,0x08,
    0x20,0x30,0x2C,0x03,0x03,0x2C,0x30,0x20,//X 56
    
    0x08,0x38,0xC8,0x00,0xC8,0x38,0x08,0x00,
    0x00,0x00,0x20,0x3F,0x20,0x00,0x00,0x00,//Y 57
    
    0x10,0x08,0x08,0x08,0xC8,0x38,0x08,0x00,
    0x20,0x38,0x26,0x21,0x20,0x20,0x18,0x00,//Z 58
    
    0x00,0x00,0x00,0xFE,0x02,0x02,0x02,0x00,
    0x00,0x00,0x00,0x7F,0x40,0x40,0x40,0x00,//[ 59
    
    0x00,0x0C,0x30,0xC0,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x01,0x06,0x38,0xC0,0x00,//\ 60
    
    0x00,0x02,0x02,0x02,0xFE,0x00,0x00,0x00,
    0x00,0x40,0x40,0x40,0x7F,0x00,0x00,0x00,//] 61
    
    0x00,0x00,0x04,0x02,0x02,0x02,0x04,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//^ 62
    
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
    0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,//_ 63
    
    0x00,0x02,0x02,0x04,0x00,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//` 64
    
    0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
    0x00,0x19,0x24,0x22,0x22,0x22,0x3F,0x20,//a 65
    
    0x08,0xF8,0x00,0x80,0x80,0x00,0x00,0x00,
    0x00,0x3F,0x11,0x20,0x20,0x11,0x0E,0x00,//b 66
    
    0x00,0x00,0x00,0x80,0x80,0x80,0x00,0x00,
    0x00,0x0E,0x11,0x20,0x20,0x20,0x11,0x00,//c 67
    
    0x00,0x00,0x00,0x80,0x80,0x88,0xF8,0x00,
    0x00,0x0E,0x11,0x20,0x20,0x10,0x3F,0x20,//d 68
    
    0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
    0x00,0x1F,0x22,0x22,0x22,0x22,0x13,0x00,//e 69
    
    0x00,0x80,0x80,0xF0,0x88,0x88,0x88,0x18,
    0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//f 70
    
    0x00,0x00,0x80,0x80,0x80,0x80,0x80,0x00,
    0x00,0x6B,0x94,0x94,0x94,0x93,0x60,0x00,//g 71
    
    0x08,0xF8,0x00,0x80,0x80,0x80,0x00,0x00,
    0x20,0x3F,0x21,0x00,0x00,0x20,0x3F,0x20,//h 72
    
    0x00,0x80,0x98,0x98,0x00,0x00,0x00,0x00,
    0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//i 73
    
    0x00,0x00,0x00,0x80,0x98,0x98,0x00,0x00,
    0x00,0xC0,0x80,0x80,0x80,0x7F,0x00,0x00,//j 74
    
    0x08,0xF8,0x00,0x00,0x80,0x80,0x80,0x00,
    0x20,0x3F,0x24,0x02,0x2D,0x30,0x20,0x00,//k 75
    
    0x00,0x08,0x08,0xF8,0x00,0x00,0x00,0x00,
    0x00,0x20,0x20,0x3F,0x20,0x20,0x00,0x00,//l 76
    
    0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x00,
    0x20,0x3F,0x20,0x00,0x3F,0x20,0x00,0x3F,//m 77
    
    0x80,0x80,0x00,0x80,0x80,0x80,0x00,0x00,
    0x20,0x3F,0x21,0x00,0x00,0x20,0x3F,0x20,//n 78
    
    0x00,0x00,0x80,0x80,0x80,0x80,0x00,0x00,
    0x00,0x1F,0x20,0x20,0x20,0x20,0x1F,0x00,//o 79
    
    0x80,0x80,0x00,0x80,0x80,0x00,0x00,0x00,
    0x80,0xFF,0xA1,0x20,0x20,0x11,0x0E,0x00,//p 80
    
    0x00,0x00,0x00,0x80,0x80,0x80,0x80,0x00,
    0x00,0x0E,0x11,0x20,0x20,0xA0,0xFF,0x80,//q 81
    
    0x80,0x80,0x80,0x00,0x80,0x80,0x80,0x00,
    0x20,0x20,0x3F,0x21,0x20,0x00,0x01,0x00,//r 82
    
    0x00,0x00,0x80,0x80,0x80,0x80,0x80,0x00,
    0x00,0x33,0x24,0x24,0x24,0x24,0x19,0x00,//s 83
    
    0x00,0x80,0x80,0xE0,0x80,0x80,0x00,0x00,
    0x00,0x00,0x00,0x1F,0x20,0x20,0x00,0x00,//t 84
    
    0x80,0x80,0x00,0x00,0x00,0x80,0x80,0x00,
    0x00,0x1F,0x20,0x20,0x20,0x10,0x3F,0x20,//u 85
    
    0x80,0x80,0x80,0x00,0x00,0x80,0x80,0x80,
    0x00,0x01,0x0E,0x30,0x08,0x06,0x01,0x00,//v 86
    
    0x80,0x80,0x00,0x80,0x00,0x80,0x80,0x80,
    0x0F,0x30,0x0C,0x03,0x0C,0x30,0x0F,0x00,//w 87
    
    0x00,0x80,0x80,0x00,0x80,0x80,0x80,0x00,
    0x00,0x20,0x31,0x2E,0x0E,0x31,0x20,0x00,//x 88
    
    0x80,0x80,0x80,0x00,0x00,0x80,0x80,0x80,
    0x80,0x81,0x8E,0x70,0x18,0x06,0x01,0x00,//y 89
    
    0x00,0x80,0x80,0x80,0x80,0x80,0x80,0x00,
    0x00,0x21,0x30,0x2C,0x22,0x21,0x30,0x00,//z 90
    
    0x00,0x00,0x00,0x00,0x80,0x7C,0x02,0x02,
    0x00,0x00,0x00,0x00,0x00,0x3F,0x40,0x40,//{ 91
    
    0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,
    0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,//| 92
    
    0x00,0x02,0x02,0x7C,0x80,0x00,0x00,0x00,
    0x00,0x40,0x40,0x3F,0x00,0x00,0x00,0x00,//} 93
    
    0x00,0x06,0x01,0x01,0x02,0x02,0x04,0x04,
    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,//~ 94
};

#endif

舵机，之前的那个是pwm控制占空比的，这个才是真正的舵机.c


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

void Servo_Init(void)
{
    PWMSG_Init();
}

void Servo_SetAngle(float Angle)
{
    PWM_SetCompare2(Angle / 180 * 2000 + 500);
}

舵机.h


##ifndef __SERVO_H
#define __SERVO_H

void Servo_Init(void);
void Servo_SetAngle(float Angle);

#endif
#ifndef __SERVO_H
#define __SERVO_H

#ifndef __SERVO_H
#define __SERVO_H

void Servo_Init(void);
void Servo_SetAngle(float Angle);

#endif

void Servo_Init(void);
void Servo_SetAngle(float Angle);

#endif
 __SERVO_H
#define __SERVO_H

void Servo_Init(void);
void Servo_SetAngle(float Angle);

#endif

循迹.c


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

    
    
void xunji_config(void)    
{
  GPIO_InitTypeDef GPIO_InitStructure;    
  RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE); // ??PC????
    
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_4 | GPIO_Pin_7;    //???????
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//??GPIO??,????       
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructure);  //???PC??
}

循迹.h


#ifndef __XUNJI_H
#define	__XUNJI_H


void xunji_config(void);


#endif

蓝牙.c


#include "stm32f10x.h"                  // Device header

void HC_05_Init(void)
{
        //ÀûÓÃÖжϽøÐÐÀ¶ÑÀµÄÊÕ·¢
    
      GPIO_InitTypeDef GPIO_InitStructure;
      USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;

      RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);    //ʹÄÜUSART1£¬GPIOAʱÖÓ
//     USART_DeInit(USART1);  //¸´Î»´®¿Ú1
//  USART1_TX   PA.9
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //¸´ÓÃÍÆÍìÊä³ö
    GPIO_Init(GPIOA, &GPIO_InitStructure); //³õʼ»¯PA9
   
    //USART1_RX      PA.10
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//¸¡¿ÕÊäÈë
    GPIO_Init(GPIOA, &GPIO_InitStructure);  //³õʼ»¯PA10     
    
     
    /* USARTx configured as follow:
       - BaudRate = 9600 baud  ²¨ÌØÂÊ
       - Word Length = 8 Bits  Êý¾Ý³¤¶È
       - One Stop Bit          ֹͣλ
       - No parity             УÑ鷽ʽ
       - Hardware flow control disabled (RTS and CTS signals) Ó²¼þ¿ØÖÆÁ÷
       - Receive and transmit enabled                         ʹÄÜ·¢ËͺͽÓÊÕ
    */
        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(USART1, &USART_InitStructure);
        USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//¿ªÆôÖжÏ

    //Usart1 NVIC ÅäÖÃ
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
      NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//ÇÀÕ¼ÓÅÏȼ¶3
      NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;        //×ÓÓÅÏȼ¶3
      NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            //IRQͨµÀʹÄÜ
      NVIC_Init(&NVIC_InitStructure);    //¸ù¾ÝÖ¸¶¨µÄ²ÎÊý³õʼ»¯VIC¼Ä´æÆ÷
    USART_Cmd(USART1, ENABLE);   
}

蓝牙.h


#ifndef __HC_05_H__
#define __HC_05_H__

void HC_05_Init(void);

#endif
STM32 智能小车源代码
07-19
STM32智能小车的源代码分享，包括launch文件，src中含有激光slam的源文件，不需要编译，可以直接用
stm32智能小车的代码
04-20
有智能小车的基本全部分代码，超声波避障，红外线控制
基于stm32智能车代码
01-13
基于STM32基础上的智能车代码，十一路传感器，亲测有效。
STM32智能小车开源代码
11-04
基于stm32的智能小车，已经实现功能：红外巡线，超声波避障，红外避障，HC05蓝牙遥控等。注释详细，对于新手是较好的电子设计入门项目。
stm32智能小车程序
02-24
stm32智能小车避障与2.4g无线遥控程序运用pwm控制四驱遥控手柄控制
基于STM32的智能小车源代码.zip
06-15
基于STM32的智能小车源代码.zip
基于STM32的智能小车
2301_78772787的博客
04-21 7105
注意：此时小车轮子并不能正常改变转动速度转动，原因是L9110电机模块每个控制口需要一高一低才可以动起来，如果PWM有效电平为高电平，则另一个 GPIO口则需要输出低电平才可以驱动轮子，解决方法是将电机模块对应的GPIO口设置低电平驱动即可。2.左循迹模块照射到黑色跑道上——左边红外被吸收不返回——左边输出高电平——指示灯灭——需要左转。3.右循迹模块照射到黑色跑道上——右边红外被吸收不返回——右边输出高电平——指示灯灭——需要右转。IA1输入高电平，IA1输入低电平，【OA1 OB1】电机正转；
STM32智能小车PID闭环速度控制基于库函数程序源代码.rar
02-18
STM32智能小车PID闭环速度控制基于库函数程序源代码。 1、本程序采用KEIL软件开发。 2、用到的库文件：Keil.STM32F1xx_DFP.2.3.0.pack。 3、程序对应处理器：STM32F103C8T6（移植到其它STM321xx系列处理器也很方便）...
stm32基于hal库的带oled的智能小车（循迹和避障），使用麦轮
最新发布
02-06
基于stm32的智能小车，使用hal库（搭配视频见上一篇博客视频）纯免费 这是免费的完整的资料，因为个人问题我没有正规的建立文件夹使用正点原子的那一套，因为有点点小麻烦，抱歉啦。后续我会改掉这个坏习惯，这个我...
使用的HAL库，基于STM32F103RBT6蓝牙控制小车
06-16
在本项目中，我们关注的是一个使用STM32F103RBT6微控制器的智能小车，它集成了HAL库来实现蓝牙控制功能。这个项目为学习者提供了实践单片机原理和嵌入式系统知识的绝佳平台，通过实际操作能够极大地提升对理论的理解...
智能小车 STM32
07-13
智能小车驱动代码；使用的是STM32；代码注释清晰；上手快；
基于STM32的智能小车源代码，主控STM32F103VET6.zip
05-24
基于STM32的智能小车源代码，主控STM32F103VET6.zip
stm32智能寻迹避障小车代码
01-27
本设计主要有三个模块，包括信号检测模块、主控模块、电机驱动模块。信号检测模块采用灰度传感器和超声波，用以对有无障碍与跟随黑线进行检测。主控电路采用STM32单片机为控制芯片。电机驱动模块采用意法半导体的298N专用电机驱动芯片，单片控制与传统分立元件电路相比，使整个系统有很好的稳定性。信号检测模块将采集到的路况信号传入STM32单片机，经单片机处理过后对298N发出指令进行相应的调整。通过有无光线接收来控制电动小车的转向，从而实现自动循迹避障的功能。
STM32F103ZET6智能小车测速程序源代码.rar
06-14
该程序源代码用于STM32F103ZET6智能小车测速运动实验。 1、采用KEIL5软件开发。 2、用到的库文件：Keil.STM32F1xx_DFP.2.3.0.pack。 3、程序对应处理器：STM32F103ZET6 4、电机驱动芯片L293D。 5、液晶模块型号：LCD1602（5V）液晶模块。 6、智能小车电机为：TT直流减速电机。 7、需要用到测速模块。 该程序源代码在本人STM32F103ZET6智能小车上亲测可用。
智能小车驱动程序源码
04-06
智能小车的简单驱动，代码质量很高 #include "motor.h" //导入led头文件 #include "stm32f10x.h" //导入STM32官方库 #include "stm32f10x_rcc.h" //导入STM32的RCC时钟库 #include "PWM.h" //导入PWM //motor1 右轮 对应PA1 PA2 //motor2 左轮 对应 PA11 PA12 //该文件用于马达的驱动信号 控制相关运动状态 void Motor_12_Config(void) //定义初始化函数 { GPIO_InitTypeDef GPIO_InitStructure; //定义GPIO_InitTypeDef结构体 RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE); //开启引脚时钟 RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE); //开启引脚时钟 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //通用推挽输出 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //设置输出功率 GPIO_Init(GPIOA, &GPIO;_InitStructure); //初始化GPIOA的引脚参数,写进 GPIO_ResetBits(GPIOA,GPIO_Pin_1|GPIO_Pin_2); //所有引脚拉低 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11|GPIO_Pin_12; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //通用推挽输出 GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; //设置输出功率 GPIO_Init(GPIOB, &GPIO;_InitStructure); //初始化GPIOB的引脚参数,写进 GPIO_ResetBits(GPIOA,GPIO_Pin_11|GPIO_Pin_12); //所有引脚拉低 } //1是右轮，2是左轮 //下面为运动状态函数
基于stm32的智能小车，使用hal库
12-01
基于stm32的智能小车，使用hal库（搭配视频见上一篇博客视频）纯免费 这是免费的完整的资料，因为个人问题我没有正规的建立文件夹使用正点原子的那一套，因为有点点小麻烦，抱歉啦。后续我会改掉这个坏习惯，这个我...
基于蓝牙技术使用stm32制造一个智能小车 （寻迹，避障，遥控）
ssjsjss的博客
04-12 1万+
基于蓝牙技术所有stm32制造一个智能小车 （寻迹，避障，遥控）
STM32智能小车（循迹、跟随、避障、测速、蓝牙、wifi、4g、语音识别）总结
热门推荐
wei_Embedded_z的博客
11-02 6万+
STM32智能小车（循迹、跟随、避障、测速、蓝牙、wife、4g、语音识别）总结循迹小车 循迹小车 3.跟随/避障小车 4.测速小车 5.远程控制小车6.语音控制小车
stm32智能小车循迹代码标准库
01-25
### STM32标准库实现智能小车循迹功能 为了实现基于STM32的标准库编写智能小车的循迹功能，通常涉及以下几个方面： - 初始化硬件资源，包括定时器、ADC模块用于读取传感器数据以及PWM控制电机速度。 - 编写中断服务程序处理外部事件触发的情况。 - 设计主循环逻辑判断当前路径状态并调整方向。 下面是一个简化版的例子来展示如何利用STM32标准外设库完成上述任务[^1]： ```c #include "stm32f10x.h" void GPIO_Configuration(void); uint8_t Read_Track_Sensors(void); int main(void) { uint8_t track_state; /* System Clock Configuration */ RCC_DeInit(); RCC_HSEConfig(RCC_HSE_ON); // Wait till HSE is ready and activate PLL with multiplication factor 9 while (RCC_WaitForHSEStartUp() != SUCCESS) {} FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable); Flash_Latency_Setting(); RCC_PLLCLKSourceConfig(RCC_PLLSource_HSE_Div1); RCC_PLLCmd(ENABLE); while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) {}; SystemCoreClockUpdate(); SysTick_Config(SystemCoreClock / 1000); /* Configure the GPIO ports */ GPIO_Configuration(); while (1) { track_state = Read_Track_Sensors(); // 获取轨迹传感器的状态 switch(track_state){ case LEFT_LINE: Turn_Right(); break; case RIGHT_LINE: Turn_Left(); break; default : GoStraight(); break; } Delay_ms(50); // 延迟一段时间再检测新的位置 } } // 定义其他必要的函数如Turn_Right(), Turn_Left(), GoStraight() ``` 此代码片段展示了基本框架，实际应用中还需要加入更多细节配置和服务例程以满足具体需求。对于更复杂的场景可能需要用到PID算法优化转向精度等问题。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

#ifndef __JUAN_H__

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

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

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

打赏作者

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

抵扣说明：

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

余额充值