Raspberry Pi - Mars Rover autónomo con seguimiento de objetos OpenCV: 7 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

Alimentado por una Raspberry Pi 3, reconocimiento de objetos de CV abierto, sensores ultrasónicos y motores de CC con engranajes. Este rover puede rastrear cualquier objeto para el que está entrenado y moverse en cualquier terreno.

Paso 1: Introducción

En este Instructables, vamos a construir un Mars Rover autónomo que puede reconocer objetos y rastrearlos usando el software Open CV que se ejecuta en una Raspberry Pi 3 con la opción de usar un dispositivo de cámara web o la cámara raspberry pi original. También está equipado con un sensor ultrasónico montado en un servo para rastrear su camino en entornos oscuros donde la cámara no funcionaría. Las señales recibidas de Pi se envían al controlador del motor IC (L293D) que impulsa 4 motores de CC de 150 RPM montados en un cuerpo construido con tuberías de PVC.

Paso 2: Materiales y software necesarios

Materiales necesarios

1. Raspberry Pi (cualquiera menos cero)
2. Cámara Raspberry PI o una cámara web
3. Controlador de motor L293D IC
4. Ruedas de robot (7x4cm) X 4
5. Motores de CC con engranajes (150 RPM) X 4
6. Tubos de PVC para chasis

Software requerido

1. Masilla para SSH ing el Pi
2. CV abierto para reconocimiento de objetos

Paso 3: construcción del chasis Rover

Para construir este chasis de PVC, necesitará

• 2 X 8"
• 2 X 4"
• 4 juntas en T

Coloque los tubos de PVC en una estructura similar a una escalera e insértelos en las juntas en T. Puede usar el sellador de PVC para hacer las juntas aún más fuertes.

Los motores de CC con engranajes se conectan con el chasis de tubería de PVC mediante abrazaderas y luego las ruedas se conectan con los motores mediante tornillos.

Paso 4: Construcción del ensamblaje del telémetro ultrasónico

El conjunto del telémetro ultrasónico se construye utilizando un sensor ultrasónico HC-SR04 conectado con un micro servomotor. Los cables están preconectados con el sensor ultrasónico antes de colocarlos en la caja de plástico que está conectada al servomotor mediante tornillos.

Paso 5: Esquemas y conexiones eléctricas

Realice las conexiones eléctricas según el diagrama de circuito adjunto.

Paso 6: Instalación de SSH y CV abierto

Ahora, necesitamos SSH en nuestra raspberry pi para instalar el software requerido. Comenzaremos por SSHing a nuestra Raspberry Pi. Asegúrese de que su Pi esté conectado al mismo enrutador que su PC y sepa que su enrutador le asignó la dirección IP. Ahora, abra un símbolo del sistema o PUTTY si está en Windows y ejecute el siguiente comando.

ssh [email protected]

La IP de su Pi puede ser diferente, la mía es 192.168.1.6.

Ahora, ingrese su contraseña predeterminada - "frambuesa"

Ahora que tiene SSH en su Pi, comencemos actualizando con este comando.

sudo apt-get update && sudo apt-get upgrade

Instalemos las herramientas necesarias para desarrolladores ahora, sudo apt-get install build-essential cmake pkg-config

A continuación, necesitamos instalar algunos paquetes de E / S de imágenes que ayudarán a nuestro Pi a obtener varios formatos de imagen del disco.

sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev

Ahora, algunos paquetes para obtener videos, transmitir en vivo y optimizar el rendimiento de OpenCV

sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev

sudo apt-get install libxvidcore-dev libx264-dev

sudo apt-get install libgtk2.0-dev libgtk-3-dev

sudo apt-get install libatlas-base-dev gfortran

También necesitamos instalar los archivos de encabezado de Python 2.7 y Python 3 para poder compilar OpenCV con enlaces de Python

sudo apt-get install python2.7-dev python3-dev

Descarga del código fuente de OpenCV

cd ~

wget -O opencv.zip

descomprimir opencv.zip

Descargando repositorio opencv_contrib

wget -O opencv_contrib.zip

descomprimir opencv_contrib.zip

También se recomienda utilizar un entorno virtual para instalar OpenCV.

sudo pip install virtualenv virtualenvwrapper

sudo rm -rf ~ /.cache / pip

Ahora, que virtualenv y virtualenvwrapper se han instalado, necesitamos actualizar nuestro ~ /.profile para incluir las siguientes líneas en la parte inferior

export WORKON_HOME = $ HOME /.virtualenvs export VIRTUALENVWRAPPER_PYTHON = / usr / bin / python3 source /usr/local/bin/virtualenvwrapper.sh

Crea tu entorno virtual python

mkvirtualenv cv -p python2

cambiar al entorno virtual creado

fuente ~ /.profile

trabajar en cv

Instalación de NumPy

pip instalar numpy

Compilar e instalar OpenCV

cd ~ / opencv-3.3.0 /

compilación de mkdir

construcción de cd

cmake -D CMAKE_BUILD_TYPE = RELEASE / -D CMAKE_INSTALL_PREFIX = / usr / local / -D INSTALL_PYTHON_EXAMPLES = ON / -D OPENCV_EXTRA_MODULES_PATH = ~ / opencv_contrib-3.3.0 / módulos / -D BUILD =

Finalmente compila OpenCV

hacer -j4

Después de que este comando termine de ejecutarse. Todo lo que necesita hacer es instalarlo.

sudo make config

sudo ldconfig

Paso 7: Ejecutar el código Python para Rover

Cree un archivo Python llamado tracker.py y agréguele el siguiente código.

sudo nano tracker.py

código:-

Programa #ASAR

# Este programa rastrea una bola roja y le indica a una frambuesa pi que la siga. import sys sys.path.append ('/ usr / local / lib / python2.7 / site-packages') import cv2 import numpy as np import os import RPi. GPIO as IO IO.setmode (IO. BOARD) IO.setup (7, IO. OUT) Configuración de IO (15, IO. OUT) Configuración de IO (13, IO. OUT) Configuración de IO (21, IO. OUT) Configuración de IO (22, IO. OUT) def fwd (): IO.output (21, 1) #Salida IO delantera izquierda del motor (22, 0) IO.output (13, 1) #Salida IO delantera derecha del motor (15, 0) def bac (): IO.output (21, 0) #Salida E / S inversa del motor izquierdo (22, 1) Salida E / S (13, 0) # Salida E / S hacia atrás del motor derecho (15, 1) def ryt (): Salida E / S (21, 0) # Salida E / S hacia atrás del motor izquierdo (22, 1) Salida E / S (13, 1) Salida E / S hacia adelante del motor derecho (15, 0) def lft (): Salida E / S (21, 1) # E / S hacia adelante del motor izquierdo.output (22, 0) IO.output (13, 0) #Right Motor hacia atrás IO.output (15, 1) def stp (): IO.output (21, 0) #Left Motor stop IO.output (22, 0) IO.output (13, 0) #Right Motor stop IO.output (15, 0) ########################### ############################################### #################### def main (): capWebcam = cv2. VideoCapture (0) # declara un Objeto VideoCapture y asociarlo a la cámara web, 0 => usar la primera cámara web # mostrar la resolución original imprimir "resolución predeterminada =" + str (capWebcam.get (cv2. CAP_PROP_FRAME_WIDTH)) + "x" + str (capWebcam.get (cv2. CAP_PROP_FRAME_HEIGHT)) capWebcam.set (cv2. CAP_PROP_FRAME_WIDTH, 320.0) # cambia la resolución a 320x240 para un procesamiento más rápido capWebcam.set (cv2. CAP_PROP_FRAME_HEIGHT, 240.0) # muestra la resolución actualizada print "updated resolution =" + str (capWebcam.get (cv2. CAP_PROWIDTH_FR)) + "x" + str (capWebcam.get (cv2. CAP_PROP_FRAME_HEIGHT)) si capWebcam.isOpened () == False: # compruebe si el objeto VideoCapture se asoció con la cámara web correctamente. Imprimir "error: no se accedió a capWebcam correctamente / n / n" # si no es así, imprima el mensaje de error para std out os.system ("pause") # pause hasta que el usuario presione una tecla para que el usuario pueda ver el mensaje de error return # y salir de la función (que sale del programa) # end if while cv2.waitKey (1)! = 27 y capWebcam.isOpened (): # hasta que se presione la tecla Esc o se pierda la conexión de la cámara web blnFrameReadSuccessf ully, imgOriginal = capWebcam.read () # lee el siguiente fotograma si no es blnFrameReadSuccessfully o imgOriginal es Ninguno: # si el fotograma no se leyó correctamente print "error: frame no leído desde la webcam / n" # mensaje de error de impresión a std out os.system ("pause") # pausa hasta que el usuario presione una tecla para que el usuario pueda ver el mensaje de error break # exit while loop (que sale del programa) # end if imgHSV = cv2.cvtColor (imgOriginal, cv2. COLOR_BGR2HSV) imgThreshLow = cv2.inRange (imgHSV, np.array ([0, 135, 135]), np.array ([18, 255, 255])) imgThreshHigh = cv2.inRange (imgHSV, np.array ([165, 135, 135]), np. array ([179, 255, 255])) imgThresh = cv2.add (imgThreshLow, imgThreshHigh) imgThresh = cv2. GaussianBlur (imgThresh, (3, 3), 2) imgThresh = cv2.dilate (imgThresh, np.ones ((5, 5), np.uint8)) imgThresh = cv2.erode (imgThresh, np.ones ((5, 5), np.uint8)) intRows, intColumns = imgThresh.shape círculos = cv2. HoughCircles (imgThresh, cv2. HOUGH_GRADIENT, 5, intRows / 4) # rellenar círculos variables con todos los círculos en la imagen procesada si hay círculos no es Ninguno: # esta línea es necesaria para evitar que el programa se bloquee en la siguiente línea si no se encontraron círculos IO. salida (7, 1) para círculo en círculos [0]: # para cada círculo x, y, radio = círculo # romper x, y, y radio imprimir "posición de la bola x =" + str (x) + ", y =" + str (y) + ", radio =" + str (radio) # imprimir la posición y el radio de la bola obRadius = int (radio) xAxis = int (x) if obRadius> 0 & obRadius100 & xAxis180: print ("Mover a la derecha") ryt () elif xAxis <100: print ("Mover a la izquierda") lft () else: stp () else: stp () cv2.circle (imgOriginal, (x, y), 3, (0, 255, 0), -1) # dibuja un pequeño círculo verde en el centro del objeto detectado cv2.circle (imgOriginal, (x, y), radio, (0, 0, 255), 3) # dibuja un círculo rojo alrededor del objeto detectado # end for # end if else: IO.output (7, 0) cv2.namedWindow ("imgOriginal", cv2. WINDOW_AUTOSIZE) # crear ventanas, use WINDOW_AUTOSIZE para un tamaño de ventana fijo cv2.namedWindow ("imgThresh", cv2. WINDOW_AUTOSIZE) # o use WINDOW_NORMAL para permitir el cambio de tamaño de la ventana cv2.imshow ("imgOriginal", imgOri ginal) # mostrar ventanas cv2.imshow ("imgThresh", imgThresh) # end while cv2.destroyAllWindows () # eliminar ventanas de la memoria return #################### ############################################### ########################### if _name_ == "_main_": main ()

Ahora, todo lo que queda por hacer es ejecutar el programa

python tracker.py

¡Felicitaciones! ¡Su vehículo autónomo está listo! La parte de navegación basada en sensores ultrasónicos se completará pronto y actualizaré este instructivo.

¡Gracias por leer!