娱乐小项目-树莓派履带小车
快速使用
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：函数结束。