Está en la página 1de 14

DEPARTAMENTO DE ELCTRICA Y ELECTRNICA

CARRERA DE INGENIERA ELECTRNICA EN AUTOMATIZACIN Y


CONTROL

ASIGNATURA: ROBTICA INDUSTRIAL

PROYECTO FINAL
Profesor: Dr. Wilbert Aguilar
INTEGRANTES
MARIA JOSE AYALA
JOSELYN GALLEGOS
DARWIN ROJAS

26 de Agosto de 2016 Sangolqui


Link : https://youtu.be/IIYRVk4RmqA

Contenido
TEMA: .................................................................................................................................3
OBJETIVOS:.........................................................................................................................3
PROBLEMA: ........................................................................................................................3
INTRODUCCIN ..................................................................................................................3
MARCO TEORICO ................................................................................................................4
Raspberry pi 2 ....................................................................................................................4
L293D ( Puente H) ..............................................................................................................4
Motores DC ......................................................................................................................5
Batera de Litio..................................................................................................................5
Robot mvil .......................................................................................................................5
Visin Artificial ..................................................................................................................6
PROCEDIMIENTO ................................................................................................................6
RESULTA DOS......................................................................................................................7
Diseo del robot ..................................................................................................................7
Deteccin de color ...............................................................................................................8
CONCLUSIONES ..................................................................................................................8
ANEXOS ..............................................................................................................................9

TEMA:
Evasin de obstculos y deteccin de color mediante robot mvil autnomo.

OBJETIVOS:
Realizar la deteccin y seguimiento de un objeto de color verde.
Implementar la evasin de obstculos en el robot mvil.

PROBLEMA:
El robot mvil debe detectar una cartulina de color verde; cada vez que el objeto cambie de
posicin el robot deber dirigirse al objetivo hasta quedar a una distancia de un metro, en
situaciones de giro del objetivo, el robot deber girar sobre su propio eje para continuar el
seguimiento del objetivo; si dicho objetivo no se encuentra visible para el robot, el miso deber
girar sobre su propio eje con la finalidad de encontrarlo o haber completado 360. En caso de
que existiera un obstculo el robot debe detenerse hasta que el obstculo no se interponga en su
camino, si el obstculo queda inmvil durante 5 segundos, el robot deber rodearlo y dirigirse al
objetivo.

INTRODUCCIN
Un robot mvil es un dispositivo mecnico el cual cuenta con sensores y actuadores,
este debe tener la capacidad de tomar decisiones mediante un sistema de control. Las
decisiones que debe tomar se encuentran basadas en la informacin capturada del
ambiente o el entorno en el que se encuentra el robot.
Con la creacin de los robots industriales, se hizo evidente lo fcil que estos pueden
llegar a chocar con su medio ambiente o incluso entre ellos mismo. Desde entonces se
ha realizado la bsqueda de mtodos anticolisin los cuales han demandado una
atencin importante por parte de los investigadores.
Este trabajo est enfocado en dotar a un robot mvil con la capacidad de seguir un
objeto (hoja) de color verde hasta quedar a 1 metro de distancia del objetivo; si un
obstculo llegar a interponerse en la trayectoria del robot, este deber detenerse y
esperar 5 segundos hasta que el obstculo se mueva, en el caso de que no exista este
movimiento por parte del obstculo el robot deber rodearlo.

MARCO TEORICO
Raspberry pi 2
Es un ordenador de placa reducida u ordenador de placa simple (SBC) de bajo coste
desarrollado en Reino Unido por la Fundacin Raspberry Pi.
Cuenta con software open source, siendo su sistema operativo oficial una versin
adaptada de Debian, denominada RaspBian, aunque permite otros sistemas operativos
incluido una versin de Windows 10.
La raspberry pi 2 tiene:
Procesador ARM Cortex-A7 de cuatro ncleos, 900 MHz
1 GB de RAM
4 puerto USB
40 pines GPIO
Puerto HDMI
Puerto Ethernet
Conector de audio de 3,5 mm
Interfaz de la cmara
Interfaz de pantalla
Ranura de tarjeta micro SD
VideoCore IV 3D ncleos grficos

Figura 1. Raspberry pi 2

L293D ( Puente H)
El integrado L293D incluye cuatro circuitos para manejar cargas de potencia media, en
especial pequeos motores y cargas inductivas, con la capacidad de controlar corriente
de hasta 600 mA en cada circuito y una tensin entre 4.5 V a 36 V.

Figura 2. L293D

Motores DC
Los motores de corriente continua tambin conocidos como motores DC trabajan o se
alimenta de corriente continua.
En robtica se utilizan frecuentemente los motores DC por la facilidad de controlarlos y
su fcil interconexin.

Figura 3. Motor DC

Batera de Litio
Es un dispositivo diseado para almacenamiento de energa elctrica que emplea como
electrolito una sal de litio que consigue los iones necesarios para la reaccin
electroqumica reversible que tiene lugar entre el ctodo y el nodo.

Figura 4. Batera de Litio

Robot mvil
Es una mquina automtica capaz de trasladarse en cualquier ambiente dado. Los robots
mviles tienen la capacidad de moverse en su entorno y no se fijan a una ubicacin
fsica.

Visin Artificial
Es una rama de la inteligencia artificial que tiene por objetivo modelar
matemticamente los procesos de percepcin visual en los seres vivos y generar
programas que permitan simular estas capacidades visuales por computadora.
La visin artificial consiste en la captacin de imgenes en lnea mediante cmaras y su
posterior tratamiento a travs de tcnicas de procesamiento avanzadas

PROCEDIMIENTO
Mediante la cmara se detecta el objeto que se va a seguir, esto se realiza mediante la
funcin videoCapture(0) asignando a la variable de cmara la primera cmara
disponible con un valor de 0 en la funcin; posteriormente se crean los controles para
indicar el color a seguir mediante la funcin createTrackbar() insertando en la misma
los valores correspondientes al color verde.
Luego se toma la muestra de los colores de cada pixel en el que se lee cada frame de la
captura mediante cap.read(); se convierte la imagen a HSV mediante cvtColor() y se
procede a detectar si en la imagen detectada por la cmara existe el objetivo (hoja de
color verde). Una vez analizado el color se binariza la imagen mediante inRange() esta
imagen contiene un mayor detalle del objeto y los filtros aplicados ayudan a eliminar
del fondo todo lo que no coincida con el objetivo, para los filtros se utiliza las funciones
erode() y dilate(). Si el objetivo se aleja a mas de 1metro de distancia el robot procede
acercarse al objetivo, si por el contrario se acerca a una distancia menor a 1 metro el
robot procede a retroceder. Si el objetivo gira a la derecha o al izquierda el robot gira
para seguir al objetivo.

Para la evasin de obstculos primero se procede a determinar el rea del obstculo


mediante la funcin moments() y localizar la posicin del objeto mostrando un circulo
verde en la posicin en la que se encuentra el objeto mediante circle(); se crean las
ventanas de salida y su respectiva configuracin mediante imshow.
Cdigo implementado (Ver Anexo A)

RESULTADOS
Diseo del robot

Deteccin de color

CONCLUSIONES

Las funciones utilizadas para la deteccin de color es lo suficientemente precisa


para cumplir con las exigencias demandadas de la aplicacin en tiempo real.

El tiempo de respuesta del robot se puede considerar como instantneo para los
requerimientos especificados en el problema.

El robot mvil tiene operacin autnoma, tomando las decisiones de


movimiento del robot mvil con base al anlisis y procesamiento de las
imgenes capturadas por su cmara web, logrando as la deteccin de color y de
obstculos en tiempo real.

La implementacin de este tipo de robots mviles puede llegar a crear


soluciones muy viables en desarrollos tecnolgicos con bajos costos y altos
beneficios, refirindose a necesidades industriales.

El diseo y construccin de este robot mvil se bas en un diseo econmico,


prctico y funcional, gracias a que su estructura fue creada desde cero por los
integrantes del grupo evitando un costo considerable en la compra de un robot
mvil.

ANEXOS
Anexo A
import
import
import
import

numpy as np
cv2
RPi.GPIO as GPIO
time

GPIO.setmode(GPIO.BOARD)
Motor1A = 16
Motor1B = 18
Motor1E = 22
Motor2A = 23
Motor2B = 21
Motor2E = 19
GPIO.setup(Motor1A,GPIO.OUT)
GPIO.setup(Motor1B,GPIO.OUT)
GPIO.setup(Motor1E,GPIO.OUT)
GPIO.setup(Motor2A,GPIO.OUT)
GPIO.setup(Motor2B,GPIO.OUT)
GPIO.setup(Motor2E,GPIO.OUT)
def nothing(x):
pass
def avanzar():
print "Adelante"
GPIO.output(Motor1A,GPIO.HIGH)
GPIO.output(Motor1B,GPIO.LOW)
GPIO.output(Motor1E,GPIO.HIGH)
GPIO.output(Motor2A,GPIO.HIGH)
GPIO.output(Motor2B,GPIO.LOW)
GPIO.output(Motor2E,GPIO.HIGH)
def retroceder():
print "Atras"
GPIO.output(Motor1A,GPIO.LOW)
GPIO.output(Motor1B,GPIO.HIGH)
GPIO.output(Motor1E,GPIO.HIGH)
GPIO.output(Motor2A,GPIO.LOW)
GPIO.output(Motor2B,GPIO.HIGH)
GPIO.output(Motor2E,GPIO.HIGH)
def derecha():
print "Derecha"
GPIO.output(Motor1A,GPIO.LOW)

GPIO.output(Motor1B,GPIO.HIGH)
GPIO.output(Motor1E,GPIO.HIGH)
GPIO.output(Motor2A,GPIO.HIGH)
GPIO.output(Motor2B,GPIO.LOW)
GPIO.output(Motor2E,GPIO.HIGH)
def izquierda():
print "Izquierda"
GPIO.output(Motor2A,GPIO.LOW)
GPIO.output(Motor2B,GPIO.HIGH)
GPIO.output(Motor2E,GPIO.HIGH)
GPIO.output(Motor1A,GPIO.HIGH)
GPIO.output(Motor1B,GPIO.LOW)
GPIO.output(Motor1E,GPIO.HIGH)
def stop():
print "Now stop"
GPIO.output(Motor1E,GPIO.LOW)
GPIO.output(Motor2E,GPIO.LOW)
def control():
k=raw_input()
print k
if k == "8": #GPIO.input(adelante):
avanzar()
elif k == "2": #GPIO.input(atras):
retroceder()
elif k == "6": #GPIO.input(derecha):
derecha()
elif k == "4": #GPIO.input(izquierda):
izquierda()
elif k == "5": #GPIO.input(stop):
stop()
print "control"
# Creamos una variable de camara y asigamos la primera camara
disponible con "0"
t_giro=0
cap = cv2.VideoCapture(0)
cv2.namedWindow('Configuracion')
# Crearemos los controles para indicar el color que seguiremos
cv2.createTrackbar ('H min', 'Configuracion', 0,180,nothing)
cv2.createTrackbar ('H max', 'Configuracion', 0,180,nothing)
cv2.createTrackbar ('S min', 'Configuracion', 0,255,nothing)
cv2.createTrackbar ('S max', 'Configuracion', 0,255,nothing)
cv2.createTrackbar ('V min', 'Configuracion', 0,255,nothing)
cv2.createTrackbar ('V max', 'Configuracion', 0,255,nothing)

area=1
areaO=0
while (area > areaO):
print "objeto"
# Iniciamos el bucle de captura, en el que leemos cada frame
de la captura
while(True):
ret, frame = cap.read()
print "Leer imagen"
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
#Convertimos imagen a HSV
# Asignamos las variables del rango de color que
seguiremos
Hmin = 45
Hmax = 58
Smin = 134
Smax = 255
Vmin = 122
Vmax = 214
OHmin = 73
OHmax = 180
OSmin = 100
OSmax = 255
OVmin = 100
OVmax = 255
# Aqui mostramos la imagen en blanco o negro segun el
rango de colores.
bn_img = cv2.inRange(hsv, np.array((Hmin,Smin,Vmin)),
np.array((Hmax,Vmax,Smax)))
img_obstaculo = cv2.inRange(hsv,
np.array((OHmin,OSmin,OVmin)), np.array((OHmax,OVmax,OSmax)))
# Limpiamos la imagen de imperfecciones con los filtros
erode y dilate
bn_img = cv2.erode
(bn_img,cv2.getStructuringElement(cv2.MORPH_RECT,(3,3)),iteratio
ns = 1)
bn_img = cv2.dilate
(bn_img,cv2.getStructuringElement(cv2.MORPH_RECT,(5,5)),iteratio
ns = 1)
img_obstaculo= cv2.erode
(img_obstaculo,cv2.getStructuringElement(cv2.MORPH_RECT,(8,8)),i
terations = 1)
img_obstaculo = cv2.dilate
(img_obstaculo,cv2.getStructuringElement(cv2.MORPH_RECT,(10,10))
,iterations = 1)
#determinar area del obstaculo
MO = cv2.moments(img_obstaculo)
areaO = MO['m00']
print "area obstaculo= ",areaO
# Localizamos la posicion del objeto

M = cv2.moments(bn_img)
area = M['m00']
print area
cx=0
if M['m00']>50000:
cx = int(M['m10']/M['m00'])
cy = int(M['m01']/M['m00'])
# Mostramos un circulo verde en la posicion en la
que se encuentra el objeto
cv2.circle (frame,(cx,cy),20,(0,255,0), 2)
print "cx=", cx
# Creamos las ventanas de salida y configuracion
cv2.imshow('Salida', frame)
cv2.imshow('inRange', bn_img)
cv2.imshow('Obstaculo', img_obstaculo)
if cv2.waitKey(1) & 0xFF == ord('q'): # Indicamos que al
pulsar "q" el programa se cierre
break
if cx >320:
derecha()
t_giro = 0
elif cx<310 and cx>0:
izquierda()
t_giro = 0
elif area > 1400000:
retroceder()
t_giro = 0
elif area < 1300000 and area > 50000:
avanzar()
t_giro = 0
if cx == 0 and area < 50000
< 50:
##

and areaO < 50000and t_giro

derecha()
t_giro = t_giro +1
print "girando tiempo= ",t_giro
if t_giro == 50:
stop()
if area < areaO :
control()

while (area < aeaO):


print "obstaculo"
# Iniciamos el bucle de captura, en el que leemos cada frame
de la captura
while(True):
ret, frame = cap.read()
print "Leer imagen"
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
#Convertimos imagen a HSV

# Asignamos las variables del rango de color que


seguiremos
Hmin = 45
Hmax = 58
Smin = 134
Smax = 255
Vmin = 122
Vmax = 214
OHmin = 73
OHmax = 180
OSmin = 100
OSmax = 255
OVmin = 100
OVmax = 255
# Aqui mostramos la imagen en blanco o negro segun el
rango de colores.
bn_img = cv2.inRange(hsv, np.array((Hmin,Smin,Vmin)),
np.array((Hmax,Vmax,Smax)))
img_obstaculo = cv2.inRange(hsv,
np.array((OHmin,OSmin,OVmin)), np.array((OHmax,OVmax,OSmax)))
# Limpiamos la imagen de imperfecciones con los filtros
erode y dilate
bn_img = cv2.erode
(bn_img,cv2.getStructuringElement(cv2.MORPH_RECT,(3,3)),iteratio
ns = 1)
bn_img = cv2.dilate
(bn_img,cv2.getStructuringElement(cv2.MORPH_RECT,(5,5)),iteratio
ns = 1)
img_obstaculo= cv2.erode
(img_obstaculo,cv2.getStructuringElement(cv2.MORPH_RECT,(8,8)),i
terations = 1)
img_obstaculo = cv2.dilate
(img_obstaculo,cv2.getStructuringElement(cv2.MORPH_RECT,(10,10))
,iterations = 1)
#determinar area del obstaculo
MO = cv2.moments(img_obstaculo)
areaO = MO['m00']
print "area obstaculo= ",areaO
# Localizamos la posicion del objeto
M = cv2.moments(bn_img)
area = M['m00']
print area
cx=0
if M['m00']>50000:
cx = int(M['m10']/M['m00'])
cy = int(M['m01']/M['m00'])
# Mostramos un circulo verde en la posicion en la
que se encuentra el objeto
cv2.circle (frame,(cx,cy),20,(0,255,0), 2)
print "cx=", cx
# Creamos las ventanas de salida y configuracion

cv2.imshow('Salida', frame)
cv2.imshow('inRange', bn_img)
cv2.imshow('Obstaculo', img_obstaculo)
if cv2.waitKey(1) & 0xFF == ord('q'): # Indicamos que al
pulsar "q" el programa se cierre
break
if cx >320:
derecha()
t_giro = 0
elif cx<310 and cx>0:
izquierda()
t_giro = 0
elif area > 1400000:
retroceder()
t_giro = 0
elif area < 1300000 and area > 50000:
avanzar()
t_giro = 0
if cx == 0 and area < 50000
< 50:
##

and areaO < 50000and t_giro

derecha()
t_giro = t_giro +1
print "girando tiempo= ",t_giro
if t_giro == 50:
stop()
if area < areaO :
control()

+cap.release()
cv2.destroyAllWindows()