精华内容
下载资源
问答
  • 智能小车项目代码.zip

    2020-03-26 08:31:09
    1.压缩包中包含服务代码、客户端代码、qt界面代码 2.代码里的端口以及ip地址需要改成自己智能小车相应的端口和ip
  • 基于stm32的智能小车,已经实现功能:红外巡线,超声波避障,红外避障,HC05蓝牙遥控等。注释详细,对于新手是较好的电子设计入门项目
  • 智能小车项目源码

    千次阅读 2018-03-11 13:48:35
    //确定小车的方向 int direction(Mat image) { namedWindow("org image", WINDOW_NORMAL); imshow("org image", image); //将原图像变为640*480 resize(image, org_image, Size(640,480), 0, 0, CV_INTER_...
    #include <stdlib.h>  
    #include <string.h>  
    #include <stdio.h>  
    #include <time.h>  
      
    #include <unistd.h>  
    #include <fcntl.h>  
    #include <termios.h>  
    #include "opencv2/core/core.hpp"  
    #include "opencv2/highgui/highgui.hpp"  
    #include "opencv2/imgproc/imgproc.hpp"  
    #include <iostream>  
      
    using namespace cv;  
    using namespace std;  
      
    #define MAX_KERNEL_LENTH (19)  
    #define MEAN_THRESH_VAL (1)  //平均阈值  
      
    int fd;  
    int fps = 100; //帧率  
    char buf[1024] = "temp text";  
    Mat org_image, blurred_image, binary_image, edge_image;  
      
    //串口设置  
    int setupSerial()  
    {  
        struct termios toptions;  
        //打开串口  
        fd = open("/dev/ttyUSB0", O_RDWR | O_NOCTTY);  
        printf("fd opened as %i\n", fd);  
        //等待Arduino启动  
        usleep(150000);  
        //获得当前串口设置  
        tcgetattr(fd, &toptions);  
      
        //设置波特率  
        cfsetispeed(&toptions, B9600);  
        cfsetospeed(&toptions, B9600);  
      
        //控制模式 ,没有奇偶校验、停止位,字符长度为8  
        toptions.c_cflag &= ~PARENB;  
        toptions.c_cflag &= ~CSTOPB;  
        toptions.c_cflag &= ~CSIZE;  
        toptions.c_cflag |= CS8;  
      
        //启用标准模式  
        toptions.c_lflag |= ICANON;  
        tcsetattr(fd, TCSANOW, &toptions);  
        printf("Attempting to communicate with arduino... \n");  
        return 0;  
    }  
      
    //命令函数  
    void sendCommand(const char* command)  
    {  
       int n;  
       write(fd, command, strlen(command)); //把命令写入fd中,并返回写的字节数  
       n = read(fd, buf, 512);             //把fd所指的文件传送到buf所指的内存中,返回读取的字节数  
       buf[n+1] = '\0';  
       //返回命令内容  
       printf("Command Returned: %s\n", buf);  
    }  
      
    //特征提取阶段:获取图像的均值  
    double value(Mat binary_image)  
    {  
        Scalar mean_scalar, stddev_scalar;  
        meanStdDev(binary_image, mean_scalar, stddev_scalar);  
        double value;  
        value = mean_scalar.val[0];  
        return value;  
    }  
      
    //确定小车的方向  
    int direction(Mat image)  
    {  
        namedWindow("org image", WINDOW_NORMAL);  
        imshow("org image", image);  
        //将原图像变为640*480  
        resize(image, org_image, Size(640,480), 0, 0, CV_INTER_LINEAR);  
      
        //模糊处理  
        for (int i = 1; i < MAX_KERNEL_LENTH; i = i + 2)  
        GaussianBlur(org_image, blurred_image, Size(1,1), 0, 0);  
        //使用恒定阈值方法去掉细节,得到阈值图像  
        threshold(org_image, binary_image, 170, 255, THRESH_BINARY);  
        //得到只有边缘信息的图像  
        Canny(blurred_image, edge_image, 45, 90);  
        //把只有边缘信息的图像叠加到二值图像上,获取边缘信息的同时也获取物体的区域信息  
        Mat binary_image1;  
        binary_image1 = binary_image + edge_image;  
      
        //闭运算  
        Mat binary_image2 = binary_image.clone();  
        Mat element = getStructuringElement(MORPH_RECT, Size(40, 40));  
        morphologyEx(binary_image1, binary_image2, MORPH_CLOSE, element);  
        namedWindow("binary", WINDOW_NORMAL);  
        imshow("binary", binary_image2);  
      
        //定义九个方位  
        Mat result[9];  
        result[0] = binary_image2(Rect(0, 0, 213, 160));  
        result[1] = binary_image2(Rect(213, 0, 213, 160));  
        result[2] = binary_image2(Rect(426, 0, 213, 160));  
        result[3] = binary_image2(Rect(0, 160, 213, 160));  
        result[4] = binary_image2(Rect(213, 160, 213, 160));  
        result[5] = binary_image2(Rect(426, 160, 213, 160));  
        result[6] = binary_image2(Rect(0, 320, 213, 160));  
        result[7] = binary_image2(Rect(213, 320, 213, 160));  
        result[8] = binary_image2(Rect(426, 320, 213, 160));  
        //计算九个方位的均值  
        double seperate_value[9];  
        for (int i = 0; i < 9; ++ i)  
            seperate_value[i] = value(result[i]);  
        //得到后面均值最小的方位  
        double min_value = 100;  
        int index = 0, key = 0;  
        for (int i = 6; i < 9; ++ i)  
            if (seperate_value[i] < min_value)  
            {  
                min_value = seperate_value[i];  
                index = i;  
            }  
        //返回车转动的方向  
         switch (index)  
           {  
               case 6: key = -1; break; //左转  
               case 8: key = 1; break;  //右转  
               default: key = 0; break; //直走  
           }  
      
           if (seperate_value[6] < 1 && seperate_value[7] < 1 && seperate_value[8] < 1)   
               key = 0;                      //没有障碍物,直接往前行驶  
           else if (seperate_value[6] > 10 && seperate_value[7] > 10 && seperate_value[8] > 10)  
               key = 9;                     //道路都被障碍物挡住,停止前进  
      
        cout << "key: " << key << endl;  
        waitKey(1);  
        return key;  
    }  
      
    int main()  
    {  
        setupSerial();  
        VideoCapture capture(0);  
        while(1)  
        {  
            capture>>org_image;  
            if(org_image.data != NULL)  
            {  
              cvtColor(org_image, org_image, COLOR_BGR2GRAY);  
              //确定前进方向并向Arduino发送命令  
              int key = direction(org_image);  
              if (key == 0)  
                 {  
                    sendCommand("f0");  
                    usleep(500000);}  
              else if (key == -1)  
                {  
                    sendCommand("s");  
                    usleep(500000);  
                    sendCommand("l60");  
                    usleep(500000);  
                }  
                else if (key == 1)  
                {  
                  sendCommand("s");  
                  usleep(500000);  
                  sendCommand("r140");  
                  usleep(500000);  
                }  
                else  
                {  
                    sendCommand("l90");  
                    usleep(500000);  
                    sendCommand("s");  
                    usleep(500000);  
                    //sendCommand("l90");  
                }  
            }  
            else  
            {  
                cout << "error:empty image!" << endl;  
                break;  
            }  
        }  
        return 0;  
    }  
    

    展开全文
  • 树莓派智能小车项目python源代码,python3.8的运行环境,包含L298驱动电机模块,tkinter图形界面控制,无线电遥控,超声波避障,红外避障,黑线循迹。 原创发布,代码规范,注释清楚,本账号下有文章详细讲解。
  • TI杯赛题文档 自学习式走迷宫智能小车代码和文档)
  • 1.Arduino 智能小车寻迹原理寻迹采用的主要原理就是 红外探测法,即利用 红外线在不同颜色的物体表面具有不同的反射性质的特点Arduino 单片机就是以是否收到反射回来的红外光为依据来确定黑线的 位置和小车的行走路线...

    1.Arduino 智能小车寻迹原理

    寻迹采用的主要原理就是 红外探测法,即利用 红外线在不同颜色的物体表面具有不同的反射性质的特点
    Arduino 单片机就是以是否收到反射回来的红外光为依据来确定黑线的 位置和小车的行走路线。
    红外探测器探测距离有限,一般最大不应超过15cm。

    对于发射和接收红外线的红外探头,可以自己制作或直接采用集成式红外探头 


    2.Arduino 寻迹模块简介




    3.Arduino pwm 调速







    4.PID算法





    5.PID 算法与寻迹







    6.代码:

    #include "pid.h"
    
    #ifdef ARDUINO_DEBUG
    int debugLeftSpeed;
    int debugRightSpeed;
    uint8_t debugIrs = 0;
    #endif
    
    const float motorSpeed = 140; //小车输出速度
    const int IR_PIN[] = {A0, A1, A2, A3, A4}; //寻迹板引脚定义
    const int IN_A1 = 7;   //
    const int IN_A2 = 6;   //
    const int IN_B1 = 5;  //
    const int IN_B2 = 4;  //
    const int _pwmLeftPin = 10;//左边 pwm 引脚
    const int _pwmRightPin = 11;//右边 pwm 引脚
    pid_t pid;
    float pidValue = 0; //pid 值
    bool turnFlag = false;
    
    void setup(void)
    {
      int i;
    
      //设置引脚功能
      pinMode(IN_A1, OUTPUT);
      pinMode(IN_A2, OUTPUT);
      pinMode(IN_B1, OUTPUT);
      pinMode(IN_B2, OUTPUT);
    
      //设置寻迹板引脚为 INPUT
      for (i = 0; i < 5; i++) {
        pinMode(IR_PIN[i], INPUT);
      }
    
    
      pid.sampleTime = SAMPLE_TIME;//初始化采样时间
      pid.Kp = KP_VALUE;
      pid.Ki = KI_VALUE;
      pid.Kd = KD_VALUE;
      pid.error = 0;
      pid.previous_error = 0;
    
      Serial.begin(115200);//设置波特率
      delay(5000);//延时 5s
    
      analogWrite(_pwmLeftPin,  motorSpeed );
      analogWrite(_pwmRightPin, motorSpeed );
    
      goForward();//小车向前行驶
    
      return;
    }
    
    
    
    
    /**
      获取寻迹板红外数据
    */
    uint8_t getIrData(void)
    {
      int i, j;
      uint8_t level;
      uint8_t temp;
      uint8_t irs[9] = {0};
    
      //获取10组数据
      for (j = 0; j < 9; j ++) {
    
          for (i = 0; i < 5; i++) {
            level = digitalRead(IR_PIN[i]);
            if (level) {
              bitSet(irs[j], i);//设置对应位为1
            } else {
              bitClear(irs[j], i);//设置对应为0
            }
          }
      }
    
      //对所有的数据进行排序
      for (i = 0; i < 9 - 1; i ++) {
        for (j = 0; j < 9 - i - 1; j ++) {
          if (irs[j] > irs[j + 1]) {
            temp = irs[j];
            irs[j] = irs[j + 1];
            irs[j + 1] = temp;
          }
        }
      }
    
    #ifdef ARDUINO_DEBUG
      debugIrs = irs[4];
    #endif
    
      //返回中间值
      return irs[4];
    }
    
    /**
       计算误差值
       @param irs :获取的寻迹传感器的值
    */
    int calcErrorByIrsValue(uint8_t irs)
    {
      int curError = pid.error;
    
      switch (irs) {
        case B11110: curError = -8; break;
    
        case B10000:
        case B11000: curError = -7; break;
    
        case B11100: curError = -6; break;
        case B11101: curError = -4; break;
        case B11001: curError = -2; break;
    
        case B00000:
        case B11011: curError = 0;  break;
    
        case B10011: curError = 2;  break;
        case B10111: curError = 4;  break;
        case B00111: curError = 6;  break;
    
        case B00011:
        case B00001: curError = 7;  break;
    
        case B01111: curError = 8;  break;
        case B11111: curError = pid.error > 0 ? 9 : - 9; break;
      }
    
      return curError;
    }
    
    
    /**
        排序函数
    */
    void _sortData(int *p, int n)
    {
      int temp;
      int i, j;
    
      for (i = 0; i < n - 1; i ++) {
        for (j = 0; j < n - i - 1; j ++) {
          if (p[j] > p[j + 1]) {
            temp = p[j];
            p[j] = p[j + 1];
            p[j + 1] = temp;
          }
        }
      }
    
      return;
    }
    
    
    /**
        计算误差值
    */
    void calcCurrentError(void)
    {
      int i;
      uint8_t irs;
      float sum = 0;
      int errorData[10];
    
      //获取 10组数据
      for (i = 0; i < 10; i ++) {
        irs =  getIrData();
        errorData[i] =  calcErrorByIrsValue(irs);
      }
    
      _sortData(errorData, 10);
    
      for (i = 1; i < 10 - 1; i ++) {
        sum += errorData[i];
      }
    
      pid.error = sum / 8;
    
      return;
    }
    
    void turnRight(void)
    {
      digitalWrite(IN_A1, LOW);
      digitalWrite(IN_A2, HIGH);
      digitalWrite(IN_B1, HIGH);
      digitalWrite(IN_B2, LOW);
    }
    
    void turnLeft(void)
    {
      digitalWrite(IN_A1, HIGH);
      digitalWrite(IN_A2, LOW);
      digitalWrite(IN_B1, LOW);
      digitalWrite(IN_B2, HIGH);
    }
    
    void goForward(void)
    {
      digitalWrite(IN_A1, HIGH);
      digitalWrite(IN_A2, LOW);
      digitalWrite(IN_B1, HIGH);
      digitalWrite(IN_B2, LOW);
    }
    
    /**
        小车控制函数
        @param pidValue : 计算出来的 pid 值
        @param turnFlag : 方向标志
    */
    void motorControl(float pidValue, bool turnFlag)
    {
    
      int leftMotorSpeed = 0;
      int rightMotorSpeed = 0;
    
      //根据 pid 的值调整小车左右电机的速度
      leftMotorSpeed  = constrain((motorSpeed + pidValue), -255, 255);
      rightMotorSpeed = constrain((motorSpeed - pidValue), -255, 255);
    
      //当转弯标志被设置时,则需要使用左边与右边的轮子 正转与反转来调整,提高调整速度
      if (turnFlag) {
        //按照较大的 pwm 值进行调整,速度最快,左边速度与右边速度一致
        if (abs(leftMotorSpeed) > abs(rightMotorSpeed)) {
          leftMotorSpeed  = abs(leftMotorSpeed);
          rightMotorSpeed = leftMotorSpeed;
        } else {
          rightMotorSpeed =  abs(rightMotorSpeed);
          leftMotorSpeed  = rightMotorSpeed;
        }
      } else {
        //当速度为正时,则取原值,当速度为负时,则取相反数,保持  pwm 的值为正值
        leftMotorSpeed  = leftMotorSpeed  > 0 ? leftMotorSpeed  : -leftMotorSpeed;
        rightMotorSpeed = rightMotorSpeed > 0 ? rightMotorSpeed : -rightMotorSpeed;
      }
    
      analogWrite(_pwmLeftPin,  leftMotorSpeed );
      analogWrite(_pwmRightPin, rightMotorSpeed);
    
    #ifdef ARDUINO_DEBUG
      debugLeftSpeed  = leftMotorSpeed ;
      debugRightSpeed = rightMotorSpeed;
    #endif
    
      return;
    }
    
    /***
        计算 pid 的值
    */
    bool calculatePid(float *pValue)
    {
      float P = 0;
      static float I = 0 ;
      float D = 0 ;
      static unsigned long lastTime = 0;
      unsigned long now = millis();
      int timeChange = now - lastTime;
    
      //没有到达采样时间
      if (timeChange < pid.sampleTime) {
        return false;
      }
    
      P = pid.error;//错误值
      I = I + pid.error;//积累误差
      D = pid.error - pid.previous_error;//计算错误的变化率
    
      *pValue = (pid.Kp * P) + (pid.Ki * I) + (pid.Kd * D) + 1;
      *pValue = constrain(*pValue, -motorSpeed,motorSpeed);
    
      pid.previous_error = pid.error;
      lastTime = now;
    
      return true;
    }
    
    #if ARDUINO_DEBUG
    void print_debug()
    {
      int i;
      String irs2bin = String(debugIrs, 2);
      int len = irs2bin.length();
      if (len < 5) {
        for (i = 0; i < 5 - len; i++) {
          irs2bin = "0" + irs2bin;
        }
      }
    
      Serial.print("IRS : ");
      Serial.print(irs2bin);
      Serial.print("   ML:");
      Serial.print(debugLeftSpeed);
      Serial.print("   MR:");
      Serial.print(debugRightSpeed);
      Serial.print("  ERROR:");
      Serial.print(pid.error, OCT);
      Serial.println();
    }
    #endif
    
    /**
        计算运动方向
    */
    void calcDirection(void)
    {
    
      if (pid.error >= 7 && pid.error <= 9) {
        turnLeft();
        turnFlag = true;
      } else if (pid.error >= -9 && pid.error <= -7) {
        turnRight();
        turnFlag = true;
      } else {
        goForward();
        turnFlag = false;
      }
    
      return;
    }
    
    void loop(void)
    {
      bool ok;
      float  pidValue;
    
      //计算错误值
      calcCurrentError();
      //计算 pid 的值
      ok = calculatePid(&pidValue);
      if (ok) {
        calcDirection();//计算小车运动方向
        motorControl(pidValue, turnFlag);//控制电机
      }
    
      //delay(500);
    
    #if ARDUINO_DEBUG
      print_debug();
      delay(1000);
    #endif
    
      return;
    }

    展开全文
  • 智能寻迹(循迹)小车项目思路 + 代码

    万次阅读 多人点赞 2021-01-21 11:40:21
    更高级的可以使用PID算法控制小车双轮的转速,从而实现智能小车控制。 作为一个项目作业,完成后想删掉的,但是感觉有些可惜,故发布于博客上以便于其他人参考。 使用两个红外线接收器接受红外线探测到的黑色轨迹,...

    说是智能循迹小车,其实一点也不智能,仅仅是几个判断语句而已。更高级的可以使用PID算法控制小车双轮的转速,从而实现智能小车控制。

    作为一个项目作业,完成后想删掉的,但是感觉有些可惜,故发布于博客上以便于其他人参考。

    使用两个红外线接收器接受红外线探测到的黑色轨迹,实现转大小弯,直角(因为直角处轨迹宽度超过了探测器的宽度,所以有一些额外处理),但是无法通过锐角。
    遇到转弯的时候就将直行的速度降低到最高速度的slow%,以防止小车冲出弯道。保持直行状态达到speedUp时间后,在fullGear-speedUp时间内将速度提升到最高,用来提升小车平均速度。每时每刻保存前一个转向状态,在传感器全为黑时执行保存的转向,以达到通过直角弯道的目的。

    流程图如下
    在这里插入图片描述

    完整代码如下

    #include<reg52.h>
    #include<intrins.h>
    #define uint unsigned int
    #define uchar unsigned char
    
    // 电机部分
    sbit P00 = P0^0;
    sbit P01 = P0^1;
    sbit P02 = P0^2;
    sbit P03 = P0^3;
    sbit P04 = P0^4; // 左电机使能
    sbit P05 = P0^5; // 右电机使能
    // 显像器部分
    sbit P20 = P2^0;
    sbit P21 = P2^1;
    sbit P22 = P2^2;
    sbit P23 = P2^3;
    sbit P24 = P2^4;
    sbit P25 = P2^5;
    sbit P26 = P2^6;
    sbit P27 = P2^7;
    // 红外部分
    sbit P33 = P3^3;
    sbit P35 = P3^5; // 左边红外
    sbit P36 = P3^6; // 右侧红外
    uint num; // 计数器
    uint pwmR;
    uint pwmL;
    // 其它参数
    uint speedUp = 5000; // 开始加速的直行时间
    uint fullGear = 8000; // 加速到满速的时间
    uint slow = 60; // 遇到转弯时的直行速度
    uint delayMs = 0; // 转弯延迟时间
    unsigned long count = 0;
    uchar status = 'F';
    uchar pstatus = 'F';
    int flag = 0; // 为0时代表全速,为1时代表转弯
    
    
    void init();
    void leftFdw();
    void leftBack();
    void rightFdw();
    void rightBack();
    void back();
    void forward();
    void turnLeft();
    void turnRight();
    void stop();
    void closeLight();
    void delayms(uint);
    void printChar(uchar x);
    void motorsWrite(int speedL, int speedR);
    
    /*************************** 车轮控制基本程序 ***************************/
    void leftFdw(){
    	// 左轮前进
    	P00 = 1;P01 = 0;
    }
    
    void leftBack(){
    	// 左轮后退
    	P00 = 0;P01 = 1;
    }
    
    void rightFdw(){
    	// 右轮前进
    	P02 = 1;P03 = 0;
    }
    
    void rightBack(){
    	// 右轮后退
    	P02 = 0;P03 = 1;
    }
    
    /*************************** 方向控制程序 ***************************/
    void turnLeft(){
    	// 左转
    	status = 'L';
    	printChar('L');
    	motorsWrite(0, 90);
    }
    
    void turnRLeft(){
    	// 左转
    	status = 'L';
    	printChar('L');
    	motorsWrite(-70, 100);
    }
    
    void turnRight(){
    	// 右转
    	status = 'R';
    	printChar('R');
    	motorsWrite(90, 0);
    }
    
    void turnRRight(){
    	// 右转
    	status = 'R';
    	printChar('R');
    	motorsWrite(100, -70);
    }
    
    void forward(){
    	// 前进
    	status = 'F';
    	printChar('F');
    	if(flag){ // 转弯
    		motorsWrite(slow,slow);
    	} else { // 直线加速
    		uint dSpeed = slow;
    		motorsWrite(dSpeed,dSpeed);
    	}
    }
    
    void back(){
    	// 后退
    	status = 'B';
    	printChar('B');
    	motorsWrite(-100,-100);
    }
    
    void stop(){
    	// 停车
    	status = 'S';
    	printChar('S');
    	motorsWrite(0,0);
    }
    
    /********************** 延时程序 **********************/
    void delayms(unsigned int xms){
    		unsigned int i,j;
    		for(i=xms;i>0;i--)
    			for(j=110;j>0;j--);
    }
    
    /********************** 数码管显示程序 **********************/
    void closeLight(){
    	P21 = 1;P22 = 1;P23 = 1;P24 = 1;P25 = 1;P26 = 1;P27 = 1;
    }
    
    void printChar(uchar x){
    	closeLight();
    //	if(x == 'L'){
    //		P22 = 0;P23 = 0;P24 = 0;
    //	} else if(x == 'R'){
    //		P22 = 0;P23 = 0;P27 = 0;
    //	} else if(x == 'F'){
    //		P21 = 0;P22 = 0;P23 = 0;P27 = 0;
    //	} else if(x == 'B'){
    //		P21 = 0;P22 = 0;P23 = 0;P24 = 0;P25 = 0;
    //	} else if(x == 'S'){
    //		P21 = 0;P24 = 0;P27 = 0;
    //	}
    }
    
    /********************** 电机控制程序 **********************/
    void motorsWrite(int speedL, int speedR){
    	// 电机控制
    	if(speedL > 100) speedL=100;
    	if(speedR > 100) speedR=100;
    	if(speedL < -100) speedL=-100;
    	if(speedR < -100) speedR=-100;
    	
    	if(speedL < 0) {
    		pwmL = -speedL;
    		leftBack();
    	} else {
    		pwmL = speedL;
    		leftFdw();
    	}
    	if(speedR < 0){
    		pwmR = -speedR;
    		rightBack();
    	} else {
    		pwmR = speedR;
    		rightFdw();
    	}
    }
    
    void init(){
    	// PWM控制程序
    	// 100us计时器
    	TMOD = 0x01; // 定时器0模式1
    	TH0 = 0x0FF; // 定时器0的高八位
    	TL0 = 0x0A4;
    	//TF0;// 如果定时器中断(溢出),则TF0=1;
    	EA = 1;
    	ET0 = 1;
    	TR0 = 1; // 表示开启定时器0
    }
    
    void main(){
    	init();
    	while(1){
    		if(P35 == 0 && P36 == 0){
    			forward();
    		} else if(P35 == 0 && P36 == 1){
    			turnRight();
    			flag = 1;
    			pstatus = 'R';
    		} else if(P35 == 1 && P36 == 0){
    			turnLeft();
    			flag = 1;
    			pstatus = 'L';
    		} else if(P35 == 1 && P36 == 1){
    			if(pstatus == 'F'){
    				forward();
    			} else if(pstatus == 'R'){
    				turnRRight();
    				delayms(delayMs);
    			} else if(pstatus == 'L'){
    				turnRLeft();
    				delayms(delayMs);
    			}
    		}
    	}
    }
    
    void Timer0Interrupt(void) interrupt 1
    {
    	TH0 = 0x0FF;
    	TL0 = 0x0A4;
    	if(num <= pwmL)P04 = 1;
    	else P04 = 0;
    	if(num <= pwmR)P05 = 1;
    	else P05 = 0;
    	num++;
    	if(num >= 100)num=0;
    	
    	if(status == 'F') {
    		count++;
    	} else {
    		count = 0;
    	}
    	if(count == speedUp && status == 'F') {
    		flag = 0;
    	}
    }
    
    展开全文
  • 智能小车代码.zip

    2020-02-25 11:51:12
    这是基于ESP32的智能小车开发项目, 使用python开编程开发, 实现小车5路红外循迹, 编码盘反馈速度, 还有陀螺仪, 加速度器, 这些传感器的数据通过WiFi连接可以发送回电脑端, 通过数据分析可以重构出小车的轨迹, 另外...
  • 项目使用光电传感器检测小车的运动轨迹,金属传感器和超声波传感器检测小车周围的障碍,对小车的相关信息进行采集,采用AVR单片机Atmega128L作为电动小车的寻迹控制,AVR单片机Atmega128L完成算法分析、信息处理和...
  • WiFi智能小车设计报告

    2019-03-25 19:23:51
    这是一个关于WiFi智能小车的设计报告内包含设计原理图,程序代码,以及设计流程。望采纳。
  • 平衡小车是用stm32做的,资料包括源码、物料清单、模块接线,模块资料,代码有注释。使用MPU6050姿态传感器模块获取小车的角度,通过串口将提取的信息送给M3,通过M3中的PID算法来计算PWM,将PWM输出至舵机来控制...
  • 智能小车项目

    2020-12-23 16:16:02
    这篇博客主要进行一次笔记汇总,设计制作一辆玩具小车,此小车系统可具有以下功能: 1)主控芯片可以采用单片机裸机运行程序,也可以采用嵌入式系统。核心 板可以采用现成的单片机最小系统板或者实验板搭建。 2)...


    这篇博客主要进行一次笔记汇总,设计制作一辆玩具小车,此小车系统可具有以下功能:超声波测距,避障,电机调速,蓝牙控制等功能,设置了两种模式避障模式与跟随模式,可以再做个循迹模式,但是没有场地不好调试就没有写了,但是原理和前两个模式是类似的,模块也是使用红外模块,可以2路也可以4路,差别不大

    模块调试部分

    1、超声波测距模块

    HC-SR04超声波测距模块的原理介绍与代码实现

    2、电机调速模块

    pwm电机调速的原理介绍与代码实现

    3、电机驱动模块

    L298N电机驱动模块的接线使用与代码实现

    4、蓝牙控制模块

    HC-05蓝牙模块遇到的问题与解决方法及实现和手机通信

    5、液晶显示模块

    LED1602液晶模组介绍及其编程使用

    6、合成语音播报模块

    TTS语音播报

    模式调试部分

    1、跟随模式
    //红外跟随模块
    void InfraredFollow_Module(void)
    {
      //设置小车速度,中档起步
     // Motor_SpeedSet(60000,0.8,0.8);
      
      while(1){
         
        //前面有障碍物,向前走
        while(Infrared_StraightMod == 0){  
            Motor_GoForward();
            delay_ms(5);
        }
        
        //左边有障碍,向左转
        while(Infrared_LeftMod == 0){  
            Motor_TurnLeft();       //左转      
            delay_ms(5);
        }
        
        //右边有障碍,向右转
        while(Infrared_RightMod == 0){ 
            Motor_TurnRight();      //右转
            delay_ms(5);
        }  
        Motor_BeParking();
      }
    }
    
    2、避障模式
    //红外避障模块
    void InfraredAvoidance_Module(void)
    {
        //设置小车速度,中档起步
     // Motor_SpeedSet(60000,0.8,0.8);
      
      while(1){
         Motor_GoForward();
         //左边有障碍
        while(Infrared_LeftMod == 0){  
            Motor_BeParking();      //停车
            delay_ms(1000);
            Motor_TurnRight();      //右转
            delay_ms(1000);
        }
        
        //右边有障碍
        while(Infrared_RightMod == 0){ 
            Motor_BeParking();      //停车
            delay_ms(1000);
            Motor_TurnLeft();       //左转
            delay_ms(1000);
        }   
        
        //前面有障碍物,思路是先后退一点点,然后右转躲避
        //还可以设置一个标志为,一次右转,一次左转;或者两到三次右转,然后一次左转
        while(Infrared_StraightMod == 0){  
            Motor_BeParking();      //停车
            delay_ms(1000);
            Motor_GetBack();        //后退
            delay_ms(1000);
            Motor_BeParking();      //停车
            delay_ms(1000);
            Motor_TurnRight();      //右转
            delay_ms(1000);
        }
      }
    }
    

    实物图

    在这里插入图片描述

    项目代码

    stm8智能跟随避障小车

    展开全文
  • 近些年随着国民生活水平的提升,以小车为载体的轮式机器人进入了我们的生活,尤其是在一些布线复杂困难的安全生活区和需要监控的施工作业场合都必须依赖轮式机器人的视频监控技术。因此,基于嵌入式技术的无线通信...
  • 本设计说明书十分详细,有图文有代码,严格按照格式完成,包括三大块:需求分析、软硬件设计...十分详细的介绍了单片机实训“循迹避障智能小车”的开发设计。能够实现蓝牙遥控、温湿度检测、循迹、避障、串口通信功能。
  • 智能小车项目计划

    2017-08-03 08:57:00
    困难在于, 驾驶过程中出现的问题难以从代码层面发现漏洞, 学习好的机器是个黑箱(被数据量包裹); 对自动驾驶汽车而言, 这种“不透明性”造成的后果非常严重: 无人车犯错了,按正常的逻辑来说,肯定是得让工程师...
  • 因此我想写这篇文章,希望你能花费更少的时间和金钱,拥有底层的可移置代码、更高端的控制理念,得到一个可持续研发的智能小车方案。智能小车真的很重要,它不仅是能够把代码与实践连接起来的简单实例,而且在即将...
  • 2021电赛F题智能送药小车,实现大部分功能,openmv识别数字 STM32
  • 四轮履带式智能小车功能: 自动避障; 智能语音控制; 手机重力感应控制; 小车音乐控制; 手机端蓝牙串口按键操作 这个是小车的功能选择控制板(buton1 进行功能选择键,...四轮履带式智能小车制作教程、源代码见附件
  • 基于STM32F103智能小车黑线寻迹运动实验(有代码)

    千次阅读 多人点赞 2020-12-16 12:44:28
    利用STM32作为智能小车的主控制器来驱动智能小车的直流电机工作,电机驱动芯片采用L298N微型集成电路电机驱动芯片,配合STM32核心板使用实现四个直流电机运行和pwm软件调速,通过改变直流电机占空比的电压来改变平均...
  • Arduino 自动避障智能小车制作教程材料:Arduino UNO r3L298N电机驱动模块小车底盘一个,万向轮一个2个电机及匹配的车轮9V电池盒及6个1.5V电池超声波测距模块及其支架9G舵机一个及其支架杜邦线若干小车图片: 连线...
  • Arduino智能物流小车项目(MEGA2560)

    万次阅读 多人点赞 2019-03-25 19:38:20
    因为这是本人做的第一个项目,然后平时也不太...去年暑假前报了某比赛,比赛要求是做一个智能物流小车项目要求小车实现的功能有—“赛道自主行走、物料扫码识别、规避障碍、跨越减速带和栅格、码垛和规避循迹的...
  • 大学项目 用32单片机编写程序 通过铜制感应线圈对电流的磁通量测量,获取道路信息
  • 智能小车——循迹、避障小车(附详细代码

    万次阅读 多人点赞 2020-06-17 00:15:56
    项目准备: stm32c8t6单片机一个 降压模块一个 L298N电机驱动模块2个、直流电机4个 TCRT5000循迹模块三个 12V锂电池一块 电路连接基本思路:12v锂电池为两个L298N电机驱动模块供电,一个L298N输出5V为C8T6单片机供电...
  • 基于QT的客户端,实现对自动导引车的远程监控,有三个线程,主线程实现图像显示,socket线程实现通信,control线程实现对小车的控制。
  •   树莓派的小项目中,我首选了智能小车这个项目作为我探索的第一个目标,因为和很多小朋友一样,对遥控小汽车有种喜欢,特别是有过小时候欲求而不得的经历的大人们哈。   其实也还有现实因素考虑,智能小车是...
  • 2021电赛F题智能送药小车程序代码

    千次阅读 2021-11-14 17:16:15
    2021电赛F题智能送药小车 原文链接:https://blog.csdn.net/cubejava/article/details/121274043 openmv巡线代码: https://download.csdn.net/download/cubejava/41873305 k210数字识别代码: ...
  • 智能倒车系统项目代码 stm32的大作业用于stm32的简单运用,摄像头很stm32板子的运用。可用于显示倒车过程中车后面的图像和距离。并且发出报警。
  • 修改车灯,变速,舵机
  • 本篇主要写一些不同功能函数的代码讲解,要看整体部分的请前往我的另一篇博客—基于Arduino(MEGA2560)的智能物流小车项目 测试部分 ▶ 此代码用于测试车轮是否正确连线,以及不同高低电平的小车行进状态。 ▶ 更改...
  • 51单片机循迹程序,智能小车驱动,红外传感器

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,895
精华内容 758
关键字:

智能小车项目代码

友情链接: TCPClient_MFC.rar