娱乐小项目-树莓派履带小车

最新推荐文章于 2024-09-02 22:45:44 发布

Jun626

最新推荐文章于 2024-09-02 22:45:44 发布

阅读量657

点赞数 10

文章标签：嵌入式硬件

本文链接：https://blog.csdn.net/Jun626/article/details/139884630

版权

快速使用

1.小车上电，开关在电源插口旁边

2.上电之后用电脑查看局域网WIFI，密码是12345678，固定IP是192.168.50.1

3.安装VNC软件：20240324_树莓派履带车\工具

4.打开VNC软件

5.在这个界面下

按ctrl+alt+t，弹出终端

6.输入python pi.py

7.再按按ctrl+alt+t，弹出终端，输入python camer1.py（如果没有弹出摄像头界面，就试试python camer.py；python camer2.py；python camer3.py）

8.打开软件20240324_树莓派履带车\dist\mycar

9.正常操作软件

1.设备连接

小车上电，开关在电源接头的旁边，上电之后等待1分钟，发现前一分钟有不稳定的情况

小车自己有一个WIFI，密码是12345678，固定IP是192.168.50.1

连接这个网络

在电脑上打开命令行，输入命令ping 192.168.50.1,确认网络联通性,

通过命令行SSH登录设备

这个方式是电脑自带的，不需要安装什么软件，相对来说比较简单

如果在这方面有什么需求，可以自行用vscode或者xshell这类软件登录

还有一个是VNC登录设备，用于摄像头控制，安装包和配套资料一起给过来了

需要换源，不然国内网络可能会导致更新有问题(目前板子里面东西太多了，没法完成更多软件的安装)

修改/etc/apt/source.list的内容

# 官方软件源
deb http://mirrors.tuna.tsinghua.edu.cn/raspbian/raspbian/ buster main contrib non-free rpi
deb-src http://mirrors.tuna.tsinghua.edu.cn/raspbian/raspbian/ buster main contrib non-free rpi

# 更新固件的软件源
deb http://mirrors.tuna.tsinghua.edu.cn/raspberrypi/ buster main ui

执行apt-get update

2.官方例程的使用

控制小车的运动

把下面的命令，一条条敲到终端运行(可以复制，不必一个字母一个字母的敲)

cd /home/pi/SmartCar
./CarRun
执行完车子会在原地运动，执行ctrl+c，结束程序

控制灯光

cd /home/pi/SmartCar ./ColorLED 执行ctrl+c，结束程序

配套的硬件程序都在/home/pi/SmartCar目录下

3.控制端程序

目前硬件几个关键的传感器或者部分有损坏，所以做了一个桌面的应用程序，不然车里面没什么好说的了

下面简单说一下程序的功能，需要自己安装python的开发环境，这个参考网上教程，就不多说了

soket连接部分

引用相关的库

import tkinter as tk
import time
import socket
import threading

实现socket连接，写收发的相关代码

HOST = ''  # 主机IP地址
PORT = 1234  # 端口号
MESSAGE_SIZE = 1024  # 消息大小
bind_ip = "192.168.50.73"

# 创建UDP套接字
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)

sock.bind((bind_ip, 1234))

def send_message(message):
    sock.sendto(message.encode(), ('192.168.50.1', 1234))

def receive_message():
    while True:
        data, address = sock.recvfrom(MESSAGE_SIZE)

        print(f"Received message: {data.decode()} from {address}")
        # 在此处处理接收到的消息

# 创建接收消息的线程
receive_thread = threading.Thread(target=receive_message)
receive_thread.daemon = True
receive_thread.start()

这段代码是一个简单的UDP网络通信的示例。它使用Python的socket模块来创建一个UDP套接字并进行数据的发送和接收。

代码中的变量解释如下：

HOST: 主机的IP地址（为空字符串表示绑定到所有可用的网络接口）
PORT: 端口号
MESSAGE_SIZE: 消息的最大大小
bind_ip: 用于绑定套接字的IP地址

接下来的代码执行以下操作：

创建一个UDP套接字对象，使用socket.socket(socket.AF_INET, socket.SOCK_DGRAM)语句，指定地址族为IPv4，套接字类型为数据报套接字。
设置套接字选项，使用sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)和sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)语句，分别启用套接字地址重用和广播功能。
使用sock.bind((bind_ip, 1234))将套接字绑定到指定的IP地址和端口号。

接下来定义了两个函数：

send_message(message)函数用于发送消息。它使用sock.sendto(message.encode(), ('192.168.50.1', 1234))语句将消息编码为字节流并发送给目标地址。
receive_message()函数用于接收消息。它通过循环不断接收数据，使用sock.recvfrom(MESSAGE_SIZE)语句接收数据和发送方的地址。然后打印接收到的消息和发送方的地址。

最后，代码创建了一个线程receive_thread，并将其设置为守护线程（daemon），然后启动线程。这个线程用于在后台不断接收消息，并在接收到消息时处理消息。

总的来说，这段代码创建了一个UDP套接字，绑定到指定的IP地址和端口号，然后通过一个线程来接收消息，并在接收到消息时进行处理。另外还提供了一个函数用于发送消息。

键盘消息响应

# 创建运动按键的回调函数
def move_forward_mouse():
    log_text.insert(tk.END, "前进\n")
    log_text.see(tk.END)
    send_message("move_forward")
    # 在此处编写前进的代码

def stop_forward_mouse():
    log_text.insert(tk.END, "停止前进\n")
    log_text.see(tk.END)
    send_message("stop_forward")
    # 在此处编写停止前进的代码

def move_backward_mouse():
    log_text.insert(tk.END, "后退\n")
    log_text.see(tk.END)
    send_message("move_backward")
    # 在此处编写后退的代码

def stop_backward_mouse():
    log_text.insert(tk.END, "停止后退\n")
    log_text.see(tk.END)
    send_message("stop_backward")
    # 在此处编写停止后退的代码

def turn_left_mouse():
    log_text.insert(tk.END, "左转\n")
    log_text.see(tk.END)
    send_message("turn_left")
    # 在此处编写左转的代码

def stop_left_mouse():
    log_text.insert(tk.END, "停止左转\n")
    log_text.see(tk.END)
    send_message("stop_left")
    # 在此处编写停止左转的代码

def turn_right_mouse():
    log_text.insert(tk.END, "右转\n")
    log_text.see(tk.END)
    send_message("turn_right")
    # 在此处编写右转的代码

def stop_right_mouse():
    log_text.insert(tk.END, "停止右转\n")
    log_text.see(tk.END)
    send_message("stop_right")
    # 在此处编写停止右转的代码
    
root.bind("<KeyPress-Up>", move_forward)
root.bind("<KeyRelease-Up>", stop_forward)
root.bind("<KeyPress-Down>", move_backward)
root.bind("<KeyRelease-Down>", stop_backward)
root.bind("<KeyPress-Left>", turn_left)
root.bind("<KeyRelease-Left>", stop_left)
root.bind("<KeyPress-Right>", turn_right)
root.bind("<KeyRelease-Right>", stop_right)

这段代码定义了一系列函数，用作按键事件的回调函数。它们用于处理运动控制按键的按下和释放事件，并在每个事件中执行相应的操作。

每个回调函数的功能如下：

move_forward_mouse()

: 当按下前进按键时，向文本框(log_text)插入"前进\n"的文本，并将其滚动到末尾可见位置。然后，通过调用send_message("move_forward")发送消息"move_forward"。在函数内部的注释处，你可以编写关于前进操作的代码。

stop_forward_mouse()

: 当释放前进按键时，向文本框(log_text)插入"停止前进\n"的文本，并将其滚动到末尾可见位置。然后，通过调用send_message("stop_forward")发送消息"stop_forward"。在函数内部的注释处，你可以编写关于停止前进操作的代码。

最后的代码段将这些回调函数与特定的按键事件绑定。它使用root.bind(, )的形式，将按键事件和相应的回调函数进行绑定。具体来说：

和事件与move_forward_mouse()和stop_forward_mouse()回调函数绑定，用于前进操作。
和事件与move_backward_mouse()和stop_backward_mouse()回调函数绑定，用于后退操作。
和事件与turn_left_mouse()和stop_left_mouse()回调函数绑定，用于左转操作。
和事件与turn_right_mouse()和stop_right_mouse()回调函数绑定，用于右转操作。

这些绑定意味着当用户按下或释放相应的按键时，与之对应的回调函数将被调用。例如，当用户按下前进按键时，move_forward_mouse()函数将被调用，文本框将显示"前进\n"，并向指定的地址发送"move_forward"的消息。

这段代码定义了一组按键事件的回调函数，用于处理运动控制按键的按下和释放事件。每个回调函数负责更新日志文本框的内容、发送相应的消息，并在函数内部的注释处编写实际的运动控制代码。最后，通过绑定按键事件和回调函数，将它们与特定的按键操作关联起来。

4.设备端程序

soket连接部分

引用相关的库

# -*- coding: utf-8 -*-
import signal
import sys
import socket
import time

signal模块用于处理信号，例如用于进程间通信或中断处理。
sys模块提供了与Python解释器和运行时环境交互的函数。
socket模块提供了网络编程相关的功能。
time模块提供了时间相关的函数。
树莓派里面，使用中文的注释，需要设置代码的编码，# -*- coding: utf-8 -*-就是用于编码格式的设置

基本程序部分

# 定义信号处理函数
def signal_handler(sig, frame):
    print("Received KeyboardInterrupt, exiting...")
    sys.exit(0)

# 注册信号处理函数
signal.signal(signal.SIGINT, signal_handler)

# 创建 socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 设置超时时间
sock.settimeout(0.1)  # 设置超时时间为10秒

# 绑定到本地端口
port = 1234
address = ('', port)
sock.bind(address)

try:
    motor_init()
    while True:
        try:
            # 接收数据
            data, address = sock.recvfrom(1024)
            message = data.decode()

            print(message)
            if message.strip() == "open beep":
                GPIO.output(buzzer, GPIO.LOW)   
            elif message.strip() == "close beep":
                GPIO.output(buzzer, GPIO.HIGH)
            elif message.strip() == "red":
                GPIO.output(red, GPIO.HIGH)
            elif message.strip() == "green":
                GPIO.output(green, GPIO.HIGH)
            elif message.strip() == "blue":
                GPIO.output(blue, GPIO.HIGH)
            elif message.strip() == "open video":
                pass
            elif message.strip() == "close video":
                pass
            elif message.strip() == "photo":
                pass    
            elif message.strip() == "move_forward":
                run(0.5)    
            elif message.strip() == "stop_forward":
                brake(0.5)        
            elif message.strip() == "move_backward":
                back(0.5)        
            elif message.strip() == "stop_backward":
                brake(0.5)    
            elif message.strip() == "turn_left":
                left(0.5)     
            elif message.strip() == "stop_left":
                brake(0.5)    
            elif message.strip() == "turn_right":
                right(0.5)    
            elif message.strip() == "stop_right":
                brake(0.5)    
            else:
                response = "命令识别失败"

            sock.sendto(message.encode(), address)
            # print(f"Received message: {data.decode()} from {address}")
        except socket.timeout:
            pass
except Exception as e:
    print("Error occurred:", e)
finally:
    sock.close()
    sys.exit()

实现了一个基于UDP协议的服务器端程序。它包含了信号处理函数、网络通信、GPIO控制等功能。

首先，定义了一个信号处理函数signal_handler，用于处理SIGINT信号（即键盘中断信号，通常由Ctrl+C触发）。在信号处理函数中，打印一条退出消息并调用sys.exit(0)退出程序。

然后，使用socket模块创建了一个UDP socket对象sock，并设置了超时时间为0.1秒。

接下来，通过sock.bind(address)将socket绑定到本地端口1234。

在一个主循环中，不断接收来自客户端的数据。使用sock.recvfrom(1024)接收数据，并将接收到的数据解码为字符串。根据接收到的消息内容，执行相应的操作，如打开/关闭蜂鸣器、控制GPIO引脚输出等。如果接收到未知的消息内容，则发送一个"命令识别失败"的响应消息。

最后，使用sock.sendto(message.encode(), address)将响应消息发送回客户端。

异常处理部分捕获任何异常，并打印出错误信息。

最后，在finally块中关闭socket并调用sys.exit()退出程序。

5.使用步骤

电脑上用python打开程序

python mycar.py

树莓派上登录VNC之后，用命令行打开程序，按ctrl+alt+t

python pi.py

通过鼠标点击软件或者用方向键可以控制程序

6.摄像头使用

代码解释

# -*- coding: utf-8 -*-
import cv2

# 创建摄像头对象
cap = cv2.VideoCapture(1)  # 0 表示默认摄像头，如果有多个摄像头可以尝试不同的索引值

# 检查摄像头是否成功打开
if not cap.isOpened():
    print("无法打开摄像头")
    exit()

# 循环读取摄像头数据
while True:
    # 逐帧捕获图像
    ret, frame = cap.read()

    # 检查图像是否成功获取
    if not ret:
        print("无法获取图像")
        break

    # 在窗口中显示图像
    cv2.imshow('Camera', frame)

    # 按下 'q' 键退出循环
    if cv2.waitKey(1) == ord('q'):
        break

# 释放摄像头资源
cap.release()

# 关闭窗口
cv2.destroyAllWindows()

使用OpenCV库进行摄像头图像捕获和显示的简单示例。

首先，导入了cv2模块，这是OpenCV库的Python接口。

接下来，通过cv2.VideoCapture()函数创建了一个摄像头对象cap，并指定摄像头的索引值为1。如果有多个摄像头可用，可以尝试不同的索引值。（硬件不稳定，有时候要自己尝试用哪个，输入命令ls /dev/video*,从数值最小的那个往上加）

然后，通过调用cap.isOpened()方法检查摄像头是否成功打开。如果摄像头无法打开，则打印一条错误消息并退出程序。

在一个主循环中，使用cap.read()方法逐帧读取摄像头数据。ret是一个布尔值，表示是否成功获取到图像帧，frame是捕获到的图像帧。

然后，检查图像是否成功获取。如果未成功获取到图像帧，则打印一条错误消息并跳出循环。

接下来，使用cv2.imshow()方法在一个名为"Camera"的窗口中显示图像帧。

通过调用cv2.waitKey(1)等待用户按键输入，如果按下键盘上的'q'键，则退出主循环。

循环结束后，使用cap.release()释放摄像头资源。

最后，调用cv2.destroyAllWindows()关闭显示图像的窗口。

7.二值化程序

程序

#--coding:utf-8 --
import cv2

# 创建摄像头对象
cap = cv2.VideoCapture(1)  # 0 表示默认摄像头，如果有多个摄像头可以尝试不同的索引值

# 检查摄像头是否成功打开
if not cap.isOpened():
    print("无法打开摄像头")
    exit()

# 循环读取摄像头数据
while True:
    # 逐帧捕获图像
    ret, frame = cap.read()

    # 检查图像是否成功获取
    if not ret:
        print("无法获取图像")
        break

    # 将图像转换为灰度图
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # 进行二值化处理
    _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)

    # 在窗口中显示二值化后的图像
    cv2.imshow('Camera', binary)

    # 按下 'q' 键退出循环
    if cv2.waitKey(1) == ord('q'):
        break

# 释放摄像头资源
cap.release()

# 关闭窗口
cv2.destroyAllWindows()

8.颜色识别

#--coding:utf-8 --
import cv2
import numpy as np

# 定义要识别的颜色范围（以HSV颜色空间为基准）
lower_red = np.array([0, 100, 100])
upper_red = np.array([10, 255, 255])
lower_green = np.array([35, 100, 100])
upper_green = np.array([85, 255, 255])
lower_blue = np.array([100, 100, 100])
upper_blue = np.array([130, 255, 255])
lower_white = np.array([0, 0, 200])
upper_white = np.array([180, 30, 255])

# 创建摄像头对象
cap = cv2.VideoCapture(0)  # 0 表示默认摄像头，如果有多个摄像头可以尝试不同的索引值

# 检查摄像头是否成功打开
if not cap.isOpened():
    print("无法打开摄像头")
    exit()

# 循环读取摄像头数据
while True:
    # 逐帧捕获图像
    ret, frame = cap.read()

    # 检查图像是否成功获取
    if not ret:
        print("无法获取图像")
        break

    # 将图像转换为HSV颜色空间
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

    # 根据颜色范围创建掩码
    mask_red = cv2.inRange(hsv, lower_red, upper_red)
    mask_green = cv2.inRange(hsv, lower_green, upper_green)
    mask_blue = cv2.inRange(hsv, lower_blue, upper_blue)
    mask_white = cv2.inRange(hsv, lower_white, upper_white)

    # 对原始图像和掩码进行按位与操作
    result_red = cv2.bitwise_and(frame, frame, mask=mask_red)
    result_green = cv2.bitwise_and(frame, frame, mask=mask_green)
    result_blue = cv2.bitwise_and(frame, frame, mask=mask_blue)
    result_white = cv2.bitwise_and(frame, frame, mask=mask_white)

    # 在窗口中显示识别结果
    cv2.imshow('Red', result_red)
    cv2.imshow('Green', result_green)
    cv2.imshow('Blue', result_blue)
    cv2.imshow('White', result_white)

    # 按下 'q' 键退出循环
    if cv2.waitKey(1) == ord('q'):
        break

# 释放摄像头资源
cap.release()

# 关闭窗口
cv2.destroyAllWindows()

首先定义了要识别的颜色范围，这里以HSV颜色空间为基准，使用np.array()创建了一个包含最低和最高颜色值的数组。

然后，我们将图像转换为HSV颜色空间，使用cv2.cvtColor()函数将BGR图像转换为HSV图像。

接下来，我们根据颜色范围创建了一个掩码，使用cv2.inRange()函数根据最低和最高颜色值在HSV图像中创建一个二值掩码。

然后，我们使用cv2.bitwise_and()函数对原始图像和掩码进行按位与操作，得到识别结果。

最后，我们在窗口中显示识别结果，并通过按下键盘上的'q'键来退出循环。

9.WEB服务控制

在电脑的浏览器输入下面的网址，会进入树莓派的WEB控制

http://yahboom4wd:8889

如要实现RGB灯的控制

点击运行就可以了

10.小车循迹

采样python调用可执行文件的方式，了解linux下程序进程的开启和关闭

实现了两个shell脚本

run.sh

#!/bin/bash
/home/pi/SmartCar/tracking &

stop.sh

#!/bin/bash
pkill -f tracking

通过subprocess实现对外部程序的调用

            elif message.strip() == "tracking":
                subprocess.Popen("/home/pi/run.sh", shell=True)
            elif message.strip() == "stop":
                brake(0.5)  
                subprocess.Popen("/home/pi/stop.sh", shell=True)

循迹逻辑

void main()
{
  //wiringPi初始化
  wiringPiSetup();
  
  //初始化电机驱动IO口为输出方式
  pinMode(Left_motor_go, OUTPUT);
  pinMode(Left_motor_back, OUTPUT);
  pinMode(Right_motor_go, OUTPUT);
  pinMode(Right_motor_back, OUTPUT);

  //创建两个软件控制的PWM脚
  softPwmCreate(Left_motor_pwm,0,255); 
  softPwmCreate(Right_motor_pwm,0,255);
  
  //定义按键接口为输入接口
  pinMode(key, INPUT);

  //定义四路循迹红外传感器为输入接口
  pinMode(TrackSensorLeftPin1, INPUT);
  pinMode(TrackSensorLeftPin2, INPUT);
  pinMode(TrackSensorRightPin1, INPUT);
  pinMode(TrackSensorRightPin2, INPUT);

  //调用按键扫描函数
//  key_scan();
  
  while(1)
  {
   //检测到黑线时循迹模块相应的指示灯亮，端口电平为LOW
   //未检测到黑线时循迹模块相应的指示灯灭，端口电平为HIGH
   TrackSensorLeftValue1  = digitalRead(TrackSensorLeftPin1);
   TrackSensorLeftValue2  = digitalRead(TrackSensorLeftPin2);
   TrackSensorRightValue1 = digitalRead(TrackSensorRightPin1);
   TrackSensorRightValue2 = digitalRead(TrackSensorRightPin2);

   //四路循迹引脚电平状态
   // 0 0 X 0
   // 1 0 X 0
   // 0 1 X 0
   //以上6种电平状态时小车原地右转，速度为250,延时80ms
   //处理右锐角和右直角的转动
   if ( (TrackSensorLeftValue1 == LOW || TrackSensorLeftValue2 == LOW) &&  TrackSensorRightValue2 == LOW)
   {
     spin_right(150, 150);
     delay(80);
   }
   //四路循迹引脚电平状态
   // 0 X 0 0       
   // 0 X 0 1 
   // 0 X 1 0       
   //处理左锐角和左直角的转动
   else if ( TrackSensorLeftValue1 == LOW && (TrackSensorRightValue1 == LOW ||  TrackSensorRightValue2 == LOW))
   {
     spin_left(150, 150);
     delay(80);
   }
   // 0 X X X
   //最左边检测到
   else if ( TrackSensorLeftValue1 == LOW)
   {
     spin_left(150, 150);
    // delay(10);
   }
   // X X X 0
   //最右边检测到
   else if ( TrackSensorRightValue2 == LOW )
   {
     spin_right(150, 150);
    // delay(10);
   }
   //四路循迹引脚电平状态
   // X 0 1 X
   //处理左小弯
   else if ( TrackSensorLeftValue2 == LOW && TrackSensorRightValue1 == HIGH)
   {
     left(0, 150);
   }
   //四路循迹引脚电平状态
   // X 1 0 X  
   //处理右小弯
   else if (TrackSensorLeftValue2 == HIGH && TrackSensorRightValue1 == LOW)
   {
     right(150, 0);
   }
   //四路循迹引脚电平状态
   // X 0 0 X
   //处理直线
   else if (TrackSensorLeftValue2 == LOW && TrackSensorRightValue1 == LOW)
   {
     run(150, 150);
   }
   //当为1 1 1 1时小车保持上一个小车运行状态
 }
 return;
}

这段代码是一个示例的C语言程序，用于控制基于树莓派的循迹小车。下面是对代码的解释：

wiringPiSetup()：这是WiringPi库的初始化函数，用于初始化树莓派的GPIO引脚。
pinMode()：这些函数用于设置引脚的输入或输出模式。例如，pinMode(Left_motor_go, OUTPUT)将Left_motor_go引脚设置为输出模式。
softPwmCreate()：这些函数用于创建软件控制的PWM脚。在这里，创建了Left_motor_pwm和Right_motor_pwm两个软件PWM引脚。
pinMode(key, INPUT)：将key引脚设置为输入模式，用于接收按键输入。
pinMode(TrackSensorLeftPin1, INPUT)等：将四个循迹红外传感器引脚设置为输入模式。
while(1)：进入主循环，程序将在这里一直运行。
检测循迹传感器状态：通过digitalRead()函数读取循迹传感器引脚的电平状态，将结果存储在相应的变量中（例如TrackSensorLeftValue1）。
根据传感器状态执行相应的动作：使用一系列的条件语句（if和else if）来判断传感器的状态，并根据情况执行相应的动作，如转弯、直行或停止。
delay()：延时函数，用于控制小车的动作持续时间。
return：函数结束。

Jun626

关注

10
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
娱乐小项目-树莓派履带小车

当按下前进按键时，向文本框(log_text)插入"前进\n"的文本，并将其滚动到末尾可见位置。每个回调函数负责更新日志文本框的内容、发送相应的消息，并在函数内部的注释处编写实际的运动控制代码。例如，当用户按下前进按键时，move_forward_mouse()函数将被调用，文本框将显示"前进\n"，并向指定的地址发送"move_forward"的消息。总的来说，这段代码创建了一个UDP套接字，绑定到指定的IP地址和端口号，然后通过一个线程来接收消息，并在接收到消息时进行处理。
复制链接

扫一扫