MICROPROCESADORES_Y_PERIFERICOS_PROYECT

Vista previa del material en texto

“MICROPROCESADORES Y PERIFÉRICOS”
PROYECTO
Comunicación serial usando Raspberry Pi 2 
(Control de un motor paso a paso) 
PROFESOR:
DAVILA JÁUREGUI AMARANTO DE JESÚS 
ESTUDIANTE:
TAPIA DE LA CRUZ JORGE EDUARDO
 
 17/ ENERO/ 2016
 
OBJETIVO:
· Diseñar un sistema basado en una computadora Raspberry PI y un motor a pasos que posicione una mesa rotatoria a diferentes ángulos. La mesa podrá tomar diferente velocidad, y moverse en sentido horario (h) y anti horario (a).
· Para poder utilizar el sistema al inicio se deberá solicitar el ingreso de una clave de 4 dígitos, si la clave es correcta se dará acceso al control de la mesa, si la calve es incorrecta se deberá mostrar el mensaje “Usted no tiene permiso de controlar este sistema” y encender un led rojo conectado al microcontrolador.
INTRODUCCIÓN 
Motores Paso a Paso (Stepper motors)
Los motores paso a paso son ideales para la construcción de mecanismos en donde se requieren movimientos muy precisos.
La característica principal de estos motores es el hecho de poder moverlos un paso a la vez por cada pulso que se le aplique. Este paso puede variar desde 90° hasta pequeños movimientos de tan solo 1.8°, es decir, que se necesitarán 4 pasos en el primer caso (90°) y 200 para el segundo caso (1.8°), para completar un giro completo de 360°.
Principio de funcionamiento
Básicamente estos motores están constituidos normalmente por un rotor sobre el que van aplicados distintos imanes permanentes y por un cierto número de bobinas excitadoras bobinadas en su estator.
Las bobinas son parte del estator y el rotor es un imán permanente. Toda la conmutación (o excitación de las bobinas) deber ser externamente manejada por un controlador.
Existen dos tipos de motores paso a paso de imán permanente:
Bipolar:
Estos tiene generalmente cuatro cables de salida (ver figura 1). Necesitan ciertos trucos para ser controlados, debido a que requieren del cambio de dirección del flujo de corriente a través de las bobinas en la secuencia apropiada para realizar un movimiento. 
En figura 3 podemos apreciar un ejemplo de control de estos motores mediante el uso de un puente en H (H-Bridge). Como se aprecia, será necesario un H-Bridge por cada bobina del motor, es decir que para controlar un motor Paso a Paso de 4 cables (dos bobinas).
Unipolar:
Estos motores suelen tener 6 o 5 cables de salida, dependiendo de su conexionado interno (ver figura 2). Este tipo se caracteriza por ser más simple de controlar.
En la figura 4. Podemos apreciar un ejemplo de conexionado para controlar un motor paso a paso unipolar mediante el uso de un ULN2803, el cual es una array de 8 transistores tipo Darlington capaces de manejar cargas de hasta 500mA. Las entradas de activación (Activa A, B, C y D) pueden ser directamente activadas por un microcontrolador.
Secuencias para manejar motores paso a paso Bipolares:
Tabla con la secuencia necesaria para controlar motores paso a paso del tipo Bipolares
Secuencias para manejar motores paso a paso Unipolares:
Secuencia Normal: Esta es la secuencia más usada y la que generalmente recomienda el fabricante. Con esta secuencia el motor avanza un paso por vez y debido a que siempre hay al menos dos bobinas activadas, se obtiene un alto torque de paso y de retención.
INTEGRADO L293D
El integrado L293D incluye cuatro circuitos para manejar cargas de potencia media, en especial pequeños motores y cargas inductivas, con la capacidad de controlar corriente hasta 600 mA en cada circuito y una tensión entre 4,5 V a 36 V.
El integrado permite formar, entonces, dos puentes H completos, con los que se puede realizar el manejo de dos motores. En este caso el manejo será bidireccional, con frenado rápido y con posibilidad de implementar fácilmente el control de velocidad.
Diagrama detallado del circuito interno
Las salidas tienen un diseño que permite el manejo directo de cargas inductivas tales como relés, solenoides, motores de corriente continua y motores por pasos, ya que incorpora internamente los diodos de protección de contracorriente para cargas inductivas.
Las entradas son compatibles con niveles de lógica TTL. Para lograr esto, incluso cuando se manejen motores de voltajes no compatibles con los niveles TTL, el chip tiene patas de alimentación separadas para la lógica (VCC1, que debe ser de 5V) y para la alimentación de la carga (VCC2, que puede ser entre 4,5V y 36V).
Las salidas poseen un circuito de manejo en configuración "tótem-pole" (término en inglés que se traduce como "poste de tótem", nombre que, gráficamente, nos remite a un "apilamiento" de transistores, como las figuras en los famosos tótems indígenas).
Ejemplo de circuito en forma de puente H (para control bidireccional del motor) y su tabla de manejo.
LISTA DE MATERIAL
· Resistencia 330Ω
· Led rojo
· Raspberry Pi 2
· Motor paso a paso
· L293D, (ULN2803)
· Puerto serial (D-SUN USB To TTL)
DESARROLLO:
Diagrama de conexión
 (L293D) El motor paso a paso tiene cinco pistas, y vamos a estar utilizando las dos mitades del L293D. El motor tiene un enchufe de 5 direcciones en el extremo.
Por energizar las bobinas en el orden correcto, el motor es impulsado ronda. El número de pasos que el motor paso a paso tiene en una rotación de 360 grados es en realidad el número de dientes de la rueda dentada. El motor estamos usando tiene 8 pasos, pero entonces el motor también incorpora una caja de engranajes de reducción de 1:64 que significa que necesita 8 x 64 = 512 pasos.
Comunicación serial usando raspberry pi.
Pasos:
1. Instalar el driver del módulo de conversión USB – serial
2. Verificar en el “administrador de dispositivos” en LPT que aparezca el puerto serial asociado al CP2102, anotar el número de puerto que le fue asignado. (El convertidor deberá estar conectado a la PC para que aparezca)
3. Realizar la conexión del convertidor a la raspberry pi. 
TX (PC) RX (Raspberry)
 RX (PC) TX (Raspberry) 
GND (PC) GND (GND)
4. Ejemplo para establecer una comunicación serial usando Python 
Primero se debe desactivar el envío de información de consola que la raspberry hace a través del puerto serie. 
sudo raspi-config
 
Posteriormente ver como se llama el puerto serie de la tarjeta: 
dmesg | grep tty 
Mostrará en pantalla: 
0,115200 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait 
 [ 0.001774] console [tty1] enabled 
 [ 0.749509] dev:f1: ttyAMA0 at MMIO 0x3f201000 (irq = 83, base_baud = 0) is a PL011 rev3 
 [ 1.268971] console [ttyAMA0] enabled 
 pi@raspberrypi ~ $ 
El nombre del puerto se muestra de forma similar al texto en negritas (ttyAMA0) 
Programa Biblioteca Rpi.GPIO
import RPi.GPIO as GPIO
import serial
import string
import time
import math 
GPIO.setmode(GPIO.BOARD)
#asignacion de pines 
LedError=15 
enable_pin = 12
bobina_A_1_pin = 7
bobina_A_2_pin = 11
bobina_B_1_pin = 16
bobina_B_2_pin = 18
GPIO.setup(LedError, GPIO.OUT) 
GPIO.setup(enable_pin, GPIO.OUT)
GPIO.setup(bobina_A_1_pin, GPIO.OUT)
GPIO.setup(bobina_A_2_pin, GPIO.OUT)
GPIO.setup(bobina_B_1_pin, GPIO.OUT)
GPIO.setup(bobina_B_2_pin, GPIO.OUT)
GPIO.output(enable_pin, 1)
print ("Bienvenidos a mi tarjeta raspberry")
usbport ='/dev/ttyAMA0' 
#configuracion puerto serial
ser = serial.Serial(usbport,9600,timeout=5.0,parity=serial.PARITY_NONE,stopbits=serial.STOPBITS_ONE) 
ser.open()
# solicitar el ingreso de una clave de 4 dígitos, si la clave es correcta se dará acceso al control de la mesa
def Ingrese(intento = 1): 
 ser.write(b"\nIngrese password:")
 respuesta = ser.readline()
 print respuesta
 if respuesta != "naranja\r": 
 if intento < 3:
 ser.write(b"\n*****ERROR***** \n Intentalo de nuevo") 
 intento =intento+1 
 Ingrese(intento)
 
 else:ser.write(b"\n***Usted no tiene permiso de controlar este sistema***\n")
 GPIO.output(LedError,GPIO.HIGH)
 time.sleep(0.9)
 GPIO.output(LedError,GPIO.LOW)
 time.sleep(0.9) 
 Ingrese(intento)
 else:
 ser.write(b"\n***Acceso al control de la mesa***\n")
#Secuencia con la que se controló el motor paso a paso Unipolar
def antihorario(retardo, pasos): 
 for i in range(0, pasos):
 setStep(1, 0, 1, 0)
 time.sleep(retardo)
 setStep(0, 1, 1, 0)
 time.sleep(retardo)
 setStep(0, 1, 0, 1)
 time.sleep(retardo)
 setStep(1, 0, 0, 1)
 time.sleep(retardo)
def horario(retardo, pasos): 
 for i in range(0, pasos):
 setStep(1, 0, 0, 1)
 time.sleep(retardo)
 setStep(0, 1, 0, 1)
 time.sleep(retardo)
 setStep(0, 1, 1, 0)
 time.sleep(retardo)
 setStep(1, 0, 1, 0)
 time.sleep(retardo)
def setStep(w1, w2, w3, w4):
 GPIO.output(bobina_A_1_pin, w1)
 GPIO.output(bobina_A_2_pin, w2)
 GPIO.output(bobina_B_1_pin, w3)
 GPIO.output(bobina_B_2_pin, w4)
 
Ingrese() 
while True: 
 ser.write("""
\nTecle el sentido del giro del motor:\n\r
 1 Sentido horario \r
 2 Sentido Antihorario \r
""")
 opcion=ser.read()
 ser.flushInput()
 ser.write("INGRESE VELOCIDAD (solo un digito):\n\r")
 retardo = ser.read(1)
 ser.flushInput()
 ser.write("INGRESE LOS GRADOS QUE DESEA MOVER EL SISTEMA (En formato de 3 digitos 000) :\n\r")
 pasos = ser.read(3)
 ser.flushInput()
 
 if retardo!='' and pasos!='':
 v1=int(retardo)/ 1000.0
 v2=int(pasos)*512 / 360
 print "v1=",v1,"v2=",v2
 if opcion == "1":
 horario(v1, v2) 
 elif opcion == "2":
 antihorario(v1, v2) 
 else:
 ser.write("\n*****Opcion Incorrecta****\n\r") 
ser.close() 
 
Ventana de terminal COM programa Tera Term (Ingresando password)
Diseño sistema basado en una computadora Raspberry PI y un motor a pasos que posicione una mesa rotatoria a diferentes ángulos.
La mesa rotatoria es un sistema que tiene una pequeña plataforma circular, esta puede ir montada sobre el eje del motor
Para probar el programa deben usar una terminal COM puede ser teraterm o puTTY, se describe como usart puTTY a continuación. 
Abrir el programa puTTY y marcar el campo serial, escribir el puerto que fue asignado al convertidor usb – serie, establecer la velocidad de comunicación.
Ventana de la LXTerminal Comunicación serial usando Raspberry Pi 2 (Control de un motor paso a paso).Para poder utilizar el sistema al inicio se deberá solicitar el ingreso de una clave de 4 dígitos, si la clave es correcta se dará acceso al control de la mesa, si la calve es incorrecta se deberá mostrar el mensaje “Usted no tiene permiso de controlar este sistema” y encender un led rojo conectado al microcontrolador.
Secuencia con la que se controló el motor paso a paso (Unipolar)
Normal: Es la secuencia más usada y la que recomiendan los fabricantes. Con esta secuencia el motor avanza un paso por vez y siempre hay dos bobinas activadas. Con esto se obtiene un mayor torque y retención.
Por energizar las bobinas en el orden correcto, el motor es impulsado ronda. El número de pasos que el motor paso a paso tiene en una rotación de 360 ​​grados es en realidad el número de dientes de la rueda dentada.
CONCLUSIONES
El proyecto presento todo un reto, fue una gran satisfacción al momento de terminarlo. 
En cuanto los motores paso a paso son dispositivos útiles y versátiles para el control de movimientos, ya que presentan una alta precisión, control de la velocidad y también en el giro del motor.
Además en este proyecto ha servido a aprender a comunicación serial con la raspberry pi 2, así como conocer el funcionamiento de los motores paso a paso, y del INTEGRADO L293D.
 
BIBLIOGRAFÍAS
Definiendo funciones en Python, librosweb visitada el día [05/01/16], encontrada: 
http://librosweb.es/libro/python/capitulo_4/definiendo_funciones.html
Manejo de potencia para motores con el integrado L293D por Eduardo J. Carletti visitada el día [03/01/16], encontrada: 
http://robots-argentina.com.ar/MotorCC_L293D.htm
Tutorial sobre Motores Paso a Paso (Stepper motors) visitada el día [03/01/16], encontrada: 
http://www.todorobot.com.ar/tutorial-sobre-motores-paso-a-paso-stepper-motors/
El control de motores de corriente continúa Usando Python Con un Raspberry Pi
http://computers.tutsplus.com/tutorials/controlling-dc-motors-using-python-with-a-raspberry-pi--cms-20051
APÉNDICE
EJEMPLO DE PROGRAMA EN C PARA CONTROLAR UN MOTOR Paso a Paso
Programa Biblioteca Rpi.GPIO
import RPi.GPIO as GPIO
import time
import math 
GPIO.setmode(GPIO.BOARD)
LedError=15 
enable_pin = 12
bobina_A_1_pin = 7
bobina_A_2_pin = 11
bobina_B_1_pin = 16
bobina_B_2_pin = 18
GPIO.setup(LedError, GPIO.OUT) 
GPIO.setup(enable_pin, GPIO.OUT)
GPIO.setup(bobina_A_1_pin, GPIO.OUT)
GPIO.setup(bobina_A_2_pin, GPIO.OUT)
GPIO.setup(bobina_B_1_pin, GPIO.OUT)
GPIO.setup(bobina_B_2_pin, GPIO.OUT)
GPIO.output(enable_pin, 1)
def Ingrese(intento = 1): 
 respuesta = raw_input("\nIngrese password: ") 
 if respuesta != "naranja": 
 if intento < 3:
 print "\n*****ERROR***** \n Intentalo de nuevo" 
 intento =intento+1 
 Ingrese(intento)
 
 else: 
 print "\n***Usted no tiene permiso de controlar este sistema***\n"
 GPIO.output(LedError,GPIO.HIGH)
 time.sleep(0.9)
 GPIO.output(LedError,GPIO.LOW)
 time.sleep(0.9) 
 Ingrese(intento)
 else:
 print "\n***Acceso al control de la mesa***\n"
 
Ingrese()
def antihorario(retardo, pasos): 
 for i in range(0, pasos):
 setStep(1, 0, 1, 0)
 time.sleep(retardo)
 setStep(0, 1, 1, 0)
 time.sleep(retardo)
 setStep(0, 1, 0, 1)
 time.sleep(retardo)
 setStep(1, 0, 0, 1)
 time.sleep(retardo)
 
def horario(retardo, pasos): 
 for i in range(0, pasos):
 setStep(1, 0, 0, 1)
 time.sleep(retardo)
 setStep(0, 1, 0, 1)
 time.sleep(retardo)
 setStep(0, 1, 1, 0)
 time.sleep(retardo)
 setStep(1, 0, 1, 0)
 time.sleep(retardo)
 
def setStep(w1, w2, w3, w4):
 GPIO.output(bobina_A_1_pin, w1)
 GPIO.output(bobina_A_2_pin, w2)
 GPIO.output(bobina_B_1_pin, w3)
 GPIO.output(bobina_B_2_pin, w4) 
while True:
 print """
Tecle el sentido del giro del motor:\n
 1 Sentido horario
 2 Sentido Antihorario
"""
 opcion=input()
 retardo = raw_input("INGRESE VELOCIDAD:")
 pasos = raw_input("INGRESE LOS GRADOS QUE DESEA MOVER EL SISTEMA :")
 if opcion == 1:
 horario(int(retardo)/ 1000.0, int(pasos)*512 / 360)
 
 elif opcion ==2: 
 antihorario(int(retardo) / 1000.0, int(pasos)*512 / 360)
 
 else:
 print "\n*****Opcion Incorrecta****\n" 
 
KeyboardInterrupt