Introducción:
Esta práctica es más amplia que las anteriores, consiste en
un mini proyecto completo con los dispositivos Raspberry PI y Arduino. La
práctica consiste en crear un servidor web en la Raspberry Pi por el cual desde
una página en internet podamos controlar un servo motor el cual está enganchado
a una cámara, y visualizar, a través de la cámara en internet, un motor paso a
paso dar 5 vueltas y un LED encenderse. El motor PaP y el Led se conectaran a Arduino
y de este a la Raspberry y solo se encenderán cuando un sensor de movimiento
detecte una entrada, este sensor se
conectara a la Raspberry Pi.
Desarrollo:
Este proyecto lo he dividido en una serie de pasos:
El primer paso que tome fue configurar el sensor de movimiento, utilice
un sensor PIR. Este sensor viene integrado en una placa con la resistencia de
protección, por lo que no hará falta conectar una resistencia externa, ya que
la Raspberry funciona a 3.3 voltios.
Cuenta con un jumper, se puede colocar en modo H o L, el modo L no sule
ser muy interesante por eso utilizaremos el modo H, que consiste en que cuando
detecte movimiento se activara durante un periodo de tiempo que controlaremos
con unos de los potenciómetros, el otro potenciómetro es para controlar la
sensibilidad del disparo. A continuación dejo el programa que controla mediante
Python el sensor PIR desde la Raspberry:
#! /usr/bin/python
# -*- coding: utf-8 -*- # Para poder ecribir en castellano.
import serial # Declaro la libreria serial.
import RPi.GPIO as GPIO #Declaro la libreria RPi.GPIO y la llamo GPIO
import time # Declaro laa libreria time.
GPIO.setmode(GPIO.BCM)# Defino los pines GPIO en modo BCM
GPIO.setup(23,GPIO.IN) # Dclaro el pin 23 GPIO como entrada.
opcion=0; #Inicializo la opcion 0.
arduino=serial.Serial('/dev/ttyACM0',9600) #Creo el objeto arduino y le
asigno la funcion serial de la libreria serial, y le meto como parametros el
puerto serie
#y la velocidad en baudios.
try:
while opcion!=1:#Mientras
opcion sea distinto de 1:
if GPIO.input(23): #Si se
detecta nivel alto por el puerto 23 entra enel if.
print('He entrado')
arduino.write('H') #
Mando un caracter a arduino por el puerto serie.
time.sleep(16) #Le doy
un retardo del tiempo que tarda el motor en dar las 5 vueltas, de este modo
evito que se acumulen lecturas y se
acumulen en el bufer.
else:
print('No He entrado')
#Si no se detecta movimiento entra en este if.
time.sleep(1)
except KeyboardInterrupt:
GPIO.cleanup() # Cierro los
puerto GPIO.
arduino.close() # Cierro el
recurso
El segundo paso fue hacer el programa para controlar el servo, el cual
también haremos en Python y controlaremos desde la Raspberry, con el siguiente
programa controlo el movimiento hacia la derecha, el programa hacia la
izquierda es similar
#!/usr/bin/python #Instrucción
para que el programa se entienda con el intérprete de python
import RPi.GPIO as GPIO #Declaramos la librería RPi.GPIO y la llamamos
GPIO
import time # Declaramos la librería time.
archivo=open("/var/www/html/variableservo.txt","r+")
# Creamos el objeto archivo, el cual abre un archivo de texto existente
guardado en la ruta indicada.
# r+ indica se puede abrir el archivo tanto a escritura como a lectura.
variable=float(archivo.read()) #Al abrir un archivo .txt los datos que
tiene guardados son de tipo string, lo cambio a tipo float para poder trabajar
con él.
archivo.close() #Cierro el recurso
GPIO.setmode(GPIO.BCM) # Activo los pines GPIO los pongo en el modo BCM
GPIO.setup(17,GPIO.OUT)# Declaro el pin GPIO 17 como salida.
p=GPIO.PWM(17,50) # Creo el objeto p para el pin GPIO 17 y le mando un
pulso de 50 ms en modo PWM.
p.start(variable-1) # Inicio el objeto p al valor que tenía el archivo
previamente abierto y le resto 1 (ya que empíricamente se observa que al poner
solo variable el primer movimiento le hace hacia el movimiento equivocado.)
time.sleep(0.5) #Le doy un breve retardo.
try:
if variable>2.5: #Si la
variable es menor de 2.5 no entra en el if y no gira el motor ya que 2.5 es el
límite del porcentaje del DutyCicle que tiene el servo.
variable2=variable-1
#Asigno a variable2 la variable -1, que es valor que quiero que se mueva el
motor.
p.ChangeDutyCycle(variable2) # Instrucción que le manda al motor un
porcentaje del DutyCicle para enviar un pulso y mover el servo.
variable22=str(variable2) #
Para guardar la nueva variable en el archivo de texto he de volverla a pasar a
tipo string.
archivo=open("variableservo.txt","w") #Vuelvo a
abrir el objeto archivo, para el mismo archivo y escribo el nuevo valor.
"w" significa que lo abres para ejecutar acción de sobre escritura.
archivo.writelines(variable22)# Escribo en a primera linea el valor de
variable22.
asciihivo.close() # Cierro
el recurso.
except KeyboardInterrupt:
GPIO.cleanup() #Cierro todos
los recursos GPIO.
p.stop()
Para saber en qué posición esta todo momento el servo se lee y se escribe
cada vez que se ejecuta en un archivo .txt, es decir nada más ejecutar el
programa se le un archivo .txt que indica el número de dutyCycle en el que está
el servo, a ese número se le suma o se le resta una constante en función de a
qué lado queramos mover el servo y se sobrescribe en el archivo .txt, de esta
manera se sabrá la próxima vez que se ejecute el programa en qué posición se
quedó el servo.
Con esto ya tendríamos los movimientos del servo, seguidamente haremos la
configuración en la Raspberry para configurar la Webcam que se conectara a la
Raspberry vía USB. Lo haremos con un software llamado motion que entre otras
cosas nos permite capturar imágenes en JPG, además de videos y demás.
El primer paso
será conectar nuestra webcam a un puerto USB de la Raspberry, comprobando que
la reconoce con el siguiente comando:
“lsusb” y en mi caso obtengo:
Actualizamos nuestra Raspberry con los
siguientes comandos:
sudo apt-get
update
sudo apt-get
upgrade
Y ya está lista
para instalar Motion con el siguiente comando:
sudo apt-get install motion que nos llevará un
par de minutos. Ahora vamos a modificar unos cuantos parámetros en el fichero
de configuración de Motion con el siguiente comando:
sudo nano /etc/motion/motion.conf
Ahora, usando los
cursores, modifico lo siguiente en el apartado #Daemon# se cambia Daemon OFF
por Daemon ON en el apartado #Snapshots# podemos cambiar el tiempo entre cada
captura de vídeo, poniendo un valor de 4 segundos entre capturas,
snapshot_interval 4 en el apartado #Live Webcam Center# ponemos webcam_port
8001 y webcam_localhost OFF en el apartado #HTTP Based Control# cambiamos a
control_port 888 y control_localhost OFF.
Ejecutamos Motion
con:
sudo motion –n y se empezará a tomar capturas
cada 4 segundos a través del puerto 8001. Para ver las imágenes de nuestra
webcam solo tenemos que escribir en la barra de dirección del Mozilla u otro
navegador http://[IP_de_la_Raspberry]:8001
El siguiente paso fue hacer el programa para mover el motor paso a paso y
encender el LED, esta parte va conectada al Arduino por lo que hare la
programación en el IDE. El motor será controlado mediante un controlador (DRV
8825). Utilizare la comunicación serie con la Raspberry para comunicarle a
Arduino cuando ha de moverse el motor y encender el LED (que será cuando el
sensor PIR detecte movimiento).
El programa para mover el PaP es el siguiente:
/*
///////////////////////////////////////////////////////////
//Autor: Guillermo Cayetano Espejo 23/01/2017 ///
///////////////////////////////////////////////////////////
// Programa: Control PaP por DVR8825 Version:1.1 ///
//Dispositivo: Atmel 328 Compilador: AVR
//Entorno IDE: 2:1.05 Simulador :Vitronic
//Tarjeta de aplicacion: Arduino
///////////////////////////////////////////////////////////
// Programa que controla un motor
paso a paso a traves de una controladora
// DRV 8825, tambien se leera por el puerto serie informacion envida
desde otro
// dispsitivo.
///////////////////////////////////////////////////////////
*/
/////////////////////Variables Globales////////////////////
#define velocidad 1700 //Defino la velocidad del motor a menos valor mas
velocidad, ya que es el tiempo en milisegundos entre paso y paso.
//Controladora DRV8825:
// El motor paso a paso se controla a traves de un driver o controlador
DVR 8825 el cual consta de una serie de pines, dos de los cuales corresponden a
los pines de control del motor que
// son el pin de dir (direccion) y el pin de step(paso), el primer pin es
una salida digital que le indica al motor la direcion de giro. El segundo
"step" es otra salida digital del controlador
// que le indica al motor el avance de un paso. Tambien el controlador
tiene otro pin que es el "reset", que mientras este a nivel bajo el
controlador permanecera apagado.
// Dispone tambien de 4 pines (B2,B1,A1 y A2) que corresponden a las
bobinas del motor PaP y van conectados a el. Por ultimo tiene dos alimenaciones
Fault es la que alimenta al controladora
// a 5v, y el otro pin de alimentacion es Vmotor que alimenta al motor a
12 voltios.
int steps=9;// Defino el pin del controlador que envia a se;al para cada
paso.
int dir=8; // Defino la direccion del motor.
int reset=10;// Defino el reset para pagary encender el controlador.
int pasos=1000;// defino el numero de pasos que quiero que de el motor,
1000 pasos equivalen a 5 vueltas(200 por vuelta).
int contador=0;//Inicializo la variable contador.
/////////////////////Funciones//////////////////////////////
////////////////////Configuracion(Setup)////////////////////
void setup(){
// Definimos los pines de salida
pinMode(dir,OUTPUT); //Declaro
los pines dir,stpes, y reset como salida
pinMode(steps,OUTPUT);
pinMode(reset,OUTPUT);
Serial.begin(9600); //Inicio la
comunicacion serie a 9600 baudios
}
//////////////////// Principal (LOOP)///////////////////////
void loop(){
if (Serial.available()){ //Si se
detecta informacion por el puerto serie entra en el if
char c=Serial.read();// Guarda en
c, que es de tipo char, la informacion que lee por el puerto serie.
if (c== 'H'){ // Si lo que se
ha guardao en c, quivale a 'H' entra en el if, y pone el contador a 0.// limpia
el buffer del puerto serie.
contador=0;
Serial.flush();// limpia el
buffer del puerto serie.
}
}
digitalWrite(reset,LOW);
//Mientras reset este a nivel bajo el controlador permanecera apagado
delay(100);
digitalWrite(reset,HIGH);
//Cuando se active reset el motor arrancara y leera los comandos enviados.
digitalWrite(dir,HIGH);
while (contador<1000){
for (int i=0; i<pasos;i++)
{
digitalWrite(steps,HIGH);//El
cambio de HIGH a LOW es lo que manda el controlador, para mandar los pulsos al
motor
delayMicroseconds(velocidad);
digitalWrite(steps,LOW);// y
girar el eje del motor invirtiendo las polaridades de las bobinas
delayMicroseconds(velocidad);
contador=contador+1;
}
}
digitalWrite(reset,LOW);
}
Para alimentar el servo hara falta una fuente externa ya que la placa
Arduino solo es capaz de ofrecer 5 voltios como máximo de salida, y el motor
funciona a unos 12 voltios.
El último paso es hacer la interfaz en la página Web, la cual hare
mediante programación en PHP y HTML.
<html>
<head>
<div
align="center">
<title>Miniproyecto</title>
</head>
<body
background="fondo.jpg">
<font
color="lime" size="38">
<h1>Mini Proyecto
Electronica</h1
</font>
<font
color="yellow" size="32">
Camara </p>
</font>
<form action="" method="post">
<input type="submit"
name="izquierda" value="←"
align="center" style="width:75px; height:60px;color:silver;
background-color:green">
<input type="submit"
name="derecha" value="→" align="center"
style="width:75px; height:60px; color:silver;
background-color:green">
<br>
</font>
<font
color="yellow" size="30">
<p>Movimiento de camara por Guillermo Cayetano</p>
</font>
<font
color="yellow" size="32">
<a
target="_blank" href="http://62.42.46.207:8001"> Camara Web</a>
</font>
</font>
<font
color="yellow" size="22">
<a
target="_blank" href="http://62.42.46.207:888"> Camara Config</a>
</font>
<br>
<br>
<img
src="imagengif.gif" align="center">
</div>
<br>
</form>
</body>
</html>
<?php
if
(isset($_POST['izquierda']))
{
exec("sudo python
/var/www/html/izquierda.py");
}
elseif
(isset($_POST['derecha']))
{
exec("sudo python
/var/www/html/derecha.py");
}
?>
La primera parte es la parte de HTML y es la que se encargara de la
apariencia de la página en general como tamaño de las letras colores, fondos, y
ubicación de los elementos. La última parte es la que asigna a los botones
creados en HTML la función correspondiente. Por ejemplo si se teclea el
pulsador “izquierda” la programación en PHP le indicara a la Raspberry que debe
ejecutar el programa llamado “izquierda.py”, que es el programa que vimos
anteriormente y que sirve para girar el servo hacia la izquierda. Y lo mismo
con el botón “derecha”.
También en la parte de HTML, hay una parte que es un hipervínculo a otra
página WEB y el cual al pinchar nos llevara a visualizar lo que está captando
la cámara Web en ese momento en tiempo real.
No hay comentarios:
Publicar un comentario