hexapodo informe proyectos 2 terminado willy
TRANSCRIPT
UNIVERSIDAD ANDINA NÉSTOR CÁCERES
VELÁSQUEZ
FACULTAD DE INGENIERIAS Y CIENCIAS PURAS
INGENIERIA ELECTRONICA Y
TELECOMUNICACIONES
PROYECTOS II
“DISEÑO Y CONSTRUCCION DE UN ROBOT
HEXÁPODO”
Integrantes:
- Wilmar Percy Yampara López
- Adolfo William Humpire Chalco
2014
AGRADECIMIENTOS:
A mis Padres por su apoyo
Moral y económico.
INTRODUCCION:
Se ha llevado a cabo el diseño y construcción de un robot móvil articulado con
patas controlado por ordenador. Se partió de un objetivo primordial: realizar el
diseño de un robot experimental con presupuesto y complejidad reducidos. El
prototipo construido, denominado Merlini, cumple este objetivo y sirve de
precedente para futuras investigaciones en este campo.
Merlini es el primer robot de este tipo construido en esta Universidad, aunque
existen antecedentes en otras Universidades y Departamentos de Investigación,
tanto Dentro como fuera de nuestro país.
No se partió de ningún trabajo previo, salvo la documentación citada en la
bibliografía, diseñándose todos los sistemas mecánicos, electrónicos e
informáticos que se consideraron necesarios. Se experimentó con diversas
estructuras mecánicas, servomecanismos de posicionamiento, electrónica de
generación de señales. Finalmente, se implantó e integró todo ello, logrando un
sistema completo y preparado para futuras extensiones
OBJETIVOS Y JUSTIFICACION DEL PROYECTO:
El principal objetivo de este proyecto es el diseño y construcción de un robot móvil
con patas, con presupuesto y complejidad reducidos.
Este objetivo plantea esfuerzos de investigación en los siguientes campos:
-Diseño de estructuras mecánicas poliarticuladas, capaces de posicionar de
manera eficiente el sistema robot (maximización del espacio alcanzable frente a
minimización de colisiones entre los elementos).
-Estudio y búsqueda de sistemas mecánicos de servocontrol (minimización del
tamaño, peso y coste frente a optimización del control en el sentido de fuerza
ejercida y reducción del error).
- Arquitecturas de control (autonomía frente a control remoto).
- Diseño de la electrónica de control y de los interfaces (estructuras
digitales para el mantenimiento de las señales de posicionamiento
y elección de dispositivos de entrada/salida para el control desde
el software).
En la implantación de todos estos sistemas se han encontrado los problemas y
restricciones enumerados a continuación:
-Limitación de presupuesto.
-Limitada disponibilidad de materiales y de medios de mecanización de los
mismos.
-Escasez de documentación sobre los dispositivos de servocontrol utilizados, y en
general, sobre los robots de este tipo realizados en otros Lugares.
-Limitación de tiempo.
-Espacio de trabajo reducido.
En general, estos problemas no se han podido obviar. El resultado final se ha
adaptado a las restricciones expuestas, consiguiendo pese a ello sus objetivos.
Estos objetivos incluyen, aparte del ya mencionado criterio de bajo coste, otros
más generales:
-Facilidad de reemplazo de componentes.
-Modularidad y reusabilidad del software.
-Sencillez de diseño.
-Preparación para futuras ampliaciones y/o mejoras.
ANTECEDENTES:
La documentación existente en el campo de los robots móviles con patas es
relativamente escasa, y se limita al desarrollo de sistemas dirigidos a objetivos
muy concretos. Por ello, durante la realización de este proyecto se pusieron en
marcha ideas, que si no son nuevas en el campo de la computación y la robótica,
si lo son aplicadas a este tipo de robots. También es a causa de esto por lo que el
diseño tuvo una gran componente de invención y experimentación, apartándose
en muchos casos de lo ya aplicado en este campo.
Existen varias formas de clasificar robots. Desde un primer punto de vista,
podemos dividir éstos en Experimentales y aplicados La primera categoría incluye
aquellos robots de propósito general diseñados para realizar un conjunto bastante
amplio de experiencias, es decir, aquellos pensados con un estricto enfoque de
investigación. La segunda categoría abarca los robots construidos con algún
propósito específico (industrial, de exploración, etc...). En esta clasificación Merlini
entraría en el primer grupo, debido a que su construcción persigue la creación de
una línea de investigación en principio sólo limitada por la estructura física del
robot, estando abierta a cualquier tipo de experiencias que se adapten a esta
restricción.
Desde otro punto de vista, se pueden encontrar robots móviles o estáticos. Los
robots industriales son fundamentalmente estáticos, es decir, incapaces de
desplazarse libremente por un entorno no limitado. Merlini es un robot móvil, por lo
que a partir de ahora la clasificación se centrará en este tipo de dispositivos.
Dentro de los robots móviles, se encuentra una primera división en robots
autónomos y no autónomos. Los primeros portan todo el software y hardware de
control sobre la estructura mecánica. Esto les da un rango de alcance limitado
únicamente por la duración de las fuentes de alimentación que utilicen, pero
encarece y produce una mayor complejidad en el sistema. Merlini es un robot no
autónomo. Es gobernado por un ordenador externo al que se comunica a través
de un Arduino Uno y Módulos de RF.
Desde un segundo punto de vista, los robots móviles pueden clasificarse
atendiendo al medio de locomoción que utilicen. Los robots con patas permiten
desplazamientos más eficientes sobre terrenos de cualquier tipo (rugosos, con
obstáculos o desniveles,...), además de ofrecer un control de estabilidad más
completo y requerir menor potencia. Los robots con otro tipo de locomoción
(ruedas, orugas, ...) simplifican el posicionamiento y los cálculos necesarios para
el mismo.
Existen diversos sistemas con patas desarrollados por Universidades u otras
entidades en los años precedentes. A continuación se comentan las
características más notables de algunos de ellos.
ROBOTS DE UNA PATA: El ejemplo más representativo es un robot desarrollado
por el Instituto de Robótica y el Departamento de Informática de la Universidad
americana Carnegie-Mellon. Este dispositivo salta sobre su única extremidad,
buscando continuamente la estabilidad dinámica, ya que la estática es imposible
en general sobre menos de cuatro patas. Supone un gran esfuerzo en el
desarrollo del sistema de control.
ROBOTS BIPEDOS: Los robots de la serie VIPER,(diseñados en la Universidad
de Tokyo, pueden caminar lateralmente, avanzar y retroceder, simulando más o
menos aproximadamente el modo de andar humano.
ROBOTS CUADRUPEDOS: Este tipo tiene más representantes fuera de nuestro
país. En el Instituto Tecnológico de Tokyo fue construido un vehículo de cuatro
patas dotado de sensores táctiles y detector de posturas. Cada pata tiene 3
grados de libertad. El control se realiza desde un microordenador que asegura la
existencia de un triángulo de apoyo sobre 3 de las patas continuamente.
ROBOTS HEXAPODOS: En la Universidad Estatal de Ohio ha sido desarrollado
un robot con 6 patas que permite al operador tomar decisiones estratégicas,
independientemente del posicionado particular de cada extremidad. Está basado
en un sistema de control consistente en 13 computadores de a bordo Intel 86/30.
En el Instituto de Robótica de la Carnegie-Mellon (EEUU) ha sido desarrollado el
AMBLER, un robot hexápodo dirigido por programas específicamente diseñados
para optimizar el movimiento de avance sobre terrenos abruptos.
DISEÑO PRELIMINAR
En este capítulo se detalla el diseño que se llevó a cabo previamente a la
construcción de Merlini. En el mismo se exponen los problemas encontrados en la
elección de la configuración mecánica y electrónica del robot, y las soluciones a
las que dieron lugar.
CONFIGURACION Y DISTRIBUCION DE LAS PATAS:
Existen varias configuraciones posibles para un robot con patas:
-Aquellas que contemplan menos de cuatro patas presentan problemas más
propios de la Ingeniería de Control que de la Computación. Dentro de los robots
de más de tres patas, los que nos interesan adoptan la forma de cuadrúpedos o
hexápodos.
-Los robots cuadrúpedos y hexápodos permiten un mayor desarrollo de los
aspectos de planificación del movimiento. En ellos los problemas derivados de la
estabilidad están relativamente simplificados o son susceptibles de simplificación,
con lo que el diseño del hardware de control se hace más sencillo. Esto añade
cierta complejidad al software, pero esa es la orientación que se pretendía dar al
proyecto.
-No hay ninguna ventaja en usar una configuración pentagonal (en todo caso
puede presentar inconvenientes debido a la más compleja simetría).
-Robots de más de seis patas sólo son útiles en campos mucho más específicos,
además de presentar un mayor coste.
Un concepto importante a la hora de elegir el número de patas del robot es el de
estabilidad estática. Este término se refiere a la capacidad del robot para
permanecer estable (sin caerse) cuando no está en movimiento. Es más fácil
mantener la estabilidad estática en un robot hexápodo que en uno cuadrúpedo por
un motivo muy sencillo: hay más patas libres para reposicionar el cuerpo del robot
mientras éste se apoya en tres de ellas. En un robot cuadrúpedo, sin embargo,
estamos obligados a utilizar un algoritmo de avance en el que las patas vayan
alternándose, puesto que sólo una está disponible una vez apoyado el robot en las
otras tres.
Por todos estos motivos, se escogió la configuración hexápoda.
ESTRUCTURA DE PATAS:
Para posicionar completamente el extremo de una pata hacen falta seis grados de libertad: tres para especificar la posición y tres para especificar la orientación. Sin embargo, puesto que el extremo de la pata se considerará puntual, no hará falta especificar su orientación. Por consiguiente, son necesarios solamente tres grados de libertad.
ARQUITECTURA DE CONTROL:
Arduino/RF
MARCO TEORICO:
ARDUINO:
Arduino es una plataforma de hardware libre, basada en una placa con un
microcontrolador y un entorno de desarrollo, diseñada para facilitar el uso de la
electrónica en proyectos multidisciplinares.
El hardware consiste en una placa con un microcontrolador Atmel AVR y puertos
de entrada/salida. Los microcontroladores más usados son el Atmega168,
Atmega328, Atmega1280, ATmega8 por su sencillez y bajo coste que permiten el
desarrollo de múltiples diseños. Por otro lado el software consiste en un entorno
de desarrollo que implementa el lenguaje de programación Processing/Wiring y el
cargador de arranque que es ejecutado en la placa.
Desde octubre de 2012, Arduino se usa también con microcontroladoras CortexM3
de ARM de 32 bits, que coexistirán con las más limitadas, pero también
económicas AVR de 8 bits. ARM y AVR no son plataformas compatibles a nivel
binario, pero se pueden programar con el mismo IDE de Arduino y hacerse
programas que compilen sin cambios en las dos plataformas. Eso sí, las
microcontroladoras CortexM3 usan 3,3V, a diferencia de la mayoría de las placas
con AVR que generalmente usan 5V. Sin embargo ya anteriormente se lanzaron
placas Arduino con Atmel AVR a 3,3V como la Arduino Fio y existen compatibles
de Arduino Nano y Pro como Meduino en que se puede conmutar el voltaje.
Arduino se puede utilizar para desarrollar objetos interactivos autónomos o puede
ser conectado a software tal como Adobe Flash, Processing, Max/MSP, Pure
Data). Las placas se pueden montar a mano o adquirirse. El entorno de desarrollo
integradolibre se puede descargar gratuitamente.
Arduino puede tomar información del entorno a través de sus entradas analógicas
y digitales, puede controlar luces, motores y otros actuadores. El microcontrolador
en la placa Arduino se programa mediante el lenguaje de programación Arduino
(basado en Wiring) y el entorno de desarrollo Arduino (basado en Processing). Los
proyectos hechos con Arduino pueden ejecutarse sin necesidad de conectar a un
computador.
El proyecto Arduino recibió una mención honorífica en la categoría de
Comunidades Digital en el Prix Ars Electrónica de 2006
MODULOS RF:
Un radiotransmisor es un dispositivo electrónico que, mediante una antena, irradia ondas
electromagnéticas que contienen (o pueden contener) información, como ocurre en el caso de las
señales de radio, televisión, telefonía móvil o cualquier otro tipo de radiocomunicación.
Transmisor en el área de comunicaciones es el origen de una sesión de comunicación. Un
transmisor es un equipo que emite una señal, código o mensaje a través de un medio. Para lograr
una sesión de comunicación se requiere: un transmisor, un medio y un receptor. En el ejemplo de
una conversación telefónica cuando Juan llama a María, Juan es el transmisor, María es el
receptor, y el medio es la línea telefónica.
El transmisor de radio es un caso particular de transmisor, en el cual el soporte físico de la
comunicación son ondas electromagnéticas. El transmisor tiene como función codificar señales
ópticas, mecánicas o eléctricas, amplificarlas, y emitirlas como ondas electromagnéticas a través
de una antena. La codificación elegida se llama modulación. Ejemplos de modulación son: la
amplitud modulada o la frecuencia modulada.
SERVOMOTORES:
Un servomotor (también llamado servo) es un dispositivo similar a un motor de corriente continua
que tiene la capacidad de ubicarse en cualquier posición dentro de su rango de operación, y
mantenerse estable en dicha posición.
Un servomotor es un motor eléctrico que puede ser controlado tanto en velocidad como en
posición.
Es posible modificar un servomotor para obtener un motor de corriente continua que, si bien ya
no tiene la capacidad de control del servo, conserva la fuerza, velocidad y baja inercia que
caracteriza a estos dispositivos.
Los servomotores hacen uso de la modulación por ancho de pulsos (PWM) para controlar la
dirección o posición de los motores de corriente continua. La mayoría trabaja en la frecuencia de
los cincuenta hercios, así las señales PWM tendrán un periodo de veinte milisegundos. La
electrónica dentro del servomotor responderá al ancho de la señal modulada. Si los circuitos
dentro del servomotor reciben una señal de entre 0,5 a 1,4 milisegundos, éste se moverá en
sentido horario; entre 1,6 a 2 milisegundos moverá el servomotor en sentido antihorario; 1,5
milisegundos representa un estado neutro para los servomotores estándares
RASPBERRY PI:
Raspberry Pi es un ordenador de placa reducida o (placa única) (SBC) de bajo coste, desarrollado
en Reino Unido por la Fundación Raspberry Pi, con el objetivo de estimular la enseñanza de
ciencias de la computación en las escuelas.
El diseño incluye un System-on-a-chip Broadcom BCM2835, que contiene un procesador central
(CPU) ARM1176JZF-S a 700 MHz (el firmware incluye unos modos “Turbo” para que el usuario
pueda hacerle overclock de hasta 1 GHz sin perder la garantía), un procesador gráfico (GPU)
VideoCore IV, y 512 MiB de memoria RAM (aunque originalmente al ser lanzado eran 256 MiB). El
diseño no incluye un disco duro ni unidad de estado sólido, ya que usa una tarjeta SD para el
almacenamiento permanente; tampoco incluye fuente de alimentación ni carcasa. El 29 de febrero
de 2012 la fundación empezó a aceptar órdenes de compra del modelo B, y el 4 de febrero de
2013 del modelo A.
La fundación da soporte para las descargas de las distribuciones para arquitectura ARM, Raspbian
(derivada de Debian), RISC OS 5, Arch Linux ARM (derivado de Arch Linux) y Pidora (derivado de
Fedora); y promueve principalmente el aprendizaje dellenguaje de programación Python . Otros
lenguajes también soportados son Tiny BASIC C, Perl y Ruby.
CARACTERISTICAS:
En enero de 2012, encuestas hechas en el Reino Unido acerca de la penetración en las aulas de
Raspberry Pi concluyeron que por cada placa que había en un colegio público, había cinco en
colegios privados. Por ello se espera que en un futuro empresas patrocinen la adquisición de
placas en colegios públicos
El CEO de Premier Farnell declaró que el gobierno de un país de medio oriente expresó interés en
proveer una placa a cada chica estudiante, con el objetivo de mejorar sus expectativas de empleo
en el futuro-
A finales de enero de 2013, se dio a conocer que Google, junto con la ayuda de otros 6 socios,
repartiría 15.000 placas entre estudiantes del Reino Unido que mostraran motivación por las
ciencias de la computación.
Software de Desarrollo de Sistemas NI LabVIEW:
El software LabVIEW es ideal para cualquier sistema de medidas y control y el
corazón de la plataforma de diseño de NI. Al integrar todas las herramientas que
los ingenieros y científicos necesitan para construir una amplia variedad de
aplicaciones en mucho menos tiempo, NI LabVIEW es un entorno de desarrollo
para resolver problemas, productividad acelerada y constante innovación.
LabVIEW es una plataforma de programación gráfica que ayuda a ingenieros a
escalar desde el diseño hasta pruebas y desde sistemas pequeños hasta grandes
sistemas. Ofrece integración sin precedentes con software legado existente, IP y
hardware al aprovechar las últimas tecnologías de cómputo. LabVIEW ofrece
herramientas para resolver los problemas de hoy en día y la capacidad para la
futura innovación, más rápido y de manera más eficiente.
El software de diseño de sistemas NI LabVIEW está en el centro de la plataforma
de National Instruments. Al proporcionar extensas herramientas que usted
necesita para construir cualquier aplicación de medida o control en mucho menos
tiempo, NI LabVIEW es el entorno de desarrollo ideal para la innovación,
descubrimiento y resultados acelerados. Combine la potencia del software
LabVIEW con hardware modular y reconfigurable para resolver la creciente
complejidad involucrada de proporcionar sistemas de medida y control a tiempo y
dentro del presupuesto
DIAGRAMA EJEMPLO DE LABVIEW:
Cámara Web LOGITECHC170:
Una cámara web o cámara de red1 (en inglés: webcam) es una pequeña cámara
digital conectada a una computadora la cual puede capturar imágenes y
transmitirlas a través de Internet, ya sea a una página web o a otra u otras
computadoras de forma privada.
Las cámaras web necesitan una computadora para transmitir las imágenes. Sin
embargo, existen otras cámaras autónomas que tan sólo necesitan un punto de
acceso a la red informática, bien sea ethernet o inalámbrico. Para diferenciarlas de
las cámaras web se las denominacámaras de red.
También son muy utilizadas en mensajería instantánea y chat como en Windows
Live Messenger,Yahoo! Messenger, Ekiga, Skype etc. En el caso del MSN
Messenger aparece un icono indicando que la otra persona tiene cámara web. Por
lo general puede transmitir imágenes en vivo, pero también puede capturar
imágenes o pequeños videos (dependiendo del programa de la cámara web) que
pueden ser grabados y transmitidos por Internet. Este se clasifica como dispositivo
de entrada, ya que por medio de él podemos transmitir imágenes hacia la
computadora.
En astronomía amateur las cámaras web de cierta calidad pueden ser utilizadas
para registrar tomas planetarias, lunares y hasta hacer algunos estudios
astrométricos de estrellas binarias. Ciertas modificaciones pueden lograr
exposiciones prolongadas que permiten obtener imágenes de objetos tenues de
cielo profundo como galaxias, nebulosas, etc.
Gracias a la instalación Plug and play, la calidad de vídeo VGA y el micrófono
integrado, esta cámara web es la manera más sencilla de iniciar videoconferencias
y enviar bonitas fotografías de alta resolución
METODOS Y PROCEDIMIENTOS:
Instalación del Sistema Operativo en la Raspberry Pi:
Raspbian es una distribución (por supuesto libre) basada en Debian optimizada
para correr sobre el hardware de la Raspberry Pi.
A modo de ejemplo, se instalara Raspbian utilizando una tarjeta de memoria SD.
En mi sistema la tarjeta de memoria es detectada como el dispositivo /dev/sdc.
Se observa que la tarjeta no posee tabla de particiones:
A continuación descargamos la última versión de Raspbian desde el siguiente
enlace:
http://downloads.raspberrypi.org/raspbian_latest
Encendemos la Raspberry, como no posee botón de encendido sólo se debe
conectar la alimentación en el puerto Micro USB:
Luego del proceso de inicio del sistema se abre la herramienta raspi-config, la cual se utiliza
para configurar Raspbian.
Expansión del sistema de archivos
La imagen está preparada para utilizar cualquier dispositivo de al menos 4Gb. El primer paso
consiste en expandir el filesystem para que ocupe toda la capacidad de la tarjeta SD:
Luego de seleccionar "Expand Filesystem" el proceso de expansión se realizará en el siguiente
reinicio (boot):
Configuración de la interfaz ethernet
Una vez reiniciado podemos ver el bonito escritorio LXDE:
El último paso es configurar la interfaz ethernet eth0:
Como usuario root (sudo su) editar el archivo /etc/network/interfaces:
Guardar y cerrar el archivo. En el siguiente reinicio, levanta la dirección IP configurada:
INSTALACION DE WEBCAM:
Aplicación para visualizar la imagen a través de un navegador: mjpg-streamer-code-181
Putty para conectarnos a la raspberry.
Una vez conectada la cámara ejecutamos “lsusb” para comprobar que nos la reconoce el
sistema.
-lsusb
Debería aparecer algo asi:
Bus 001 Device 004: ID 046d:0804 Logitech, Inc. Webcam C250
Actualizamos y instalamos librerias necerias
sudo apt-get update
sudo apt-get install libjpeg8-dev imagemagick subversion
Descomprimimos la aplicación streamer descargada y compilamos
cd mjpg-streamer/mjpg-streamer
make
Lanzamos la aplicación
./mjpg\_streamer -i "./input\_uvc.so -y -n " -o "./output_http.so -n -w ./www" &
Y nos debería mostrar las configuraciones predeterminadas
MJPG Streamer Version: svn rev: 3:172
i: Using V4L2 device.: /dev/video0 i: Desired Resolution: 640 x 480
i: Frames Per Second.: 5
i: Format............: YUV
i: JPEG Quality......: 80
o: www-folder-path...: ./www/
o: HTTP TCP port.....: 808
0 o: username:password.: disabled
o: commands..........: disabled
Finalmente desde un navegador abrimos
http://ip_del_raspberry:8080
ESTRUCTURA DE ACRILICO:
Primero se empezó Realizando las estructuras en acrílico tomando en cuenta el
tamaño de los servomotores.
Seguidamente se empezó a armar las piezas con los Servomotores.
Finalmente Quedando de esta Forma.
PROGRAMACION:
Posteriormente se Realizó la programación para el control del robot hexápodo. La
programación se realizó en Procesing que es el lenguaje del Arduino.
TRANSMISOR
Diagrama de Flujo:
P = 5 ENVIAR C = A
P = 6 ENVIAR C = D
P = 7 ENVIAR C = F
P = 8 ENVIAR C = H
ENVIAR C = J
INICIO
PROGRAMA:
#include <VirtualWire.h>
int boton = 5;
int boton2 = 6;
int boton3 = 7;
int boton4 = 8;
char *msg = "";
int ab = 0;
int eb = 0;
int ib = 0;
int ob = 0;
void setup(){
vw_setup(7000);
pinMode(boton, INPUT);
pinMode(boton2, INPUT);
pinMode(boton3, INPUT);
pinMode(boton4, INPUT);
}
void loop () {
ab = digitalRead(boton);
if ( ab == HIGH) {
msg = "A";
vw_send((uint8_t *)msg, strlen(msg));
}
else {
msg = "B";
vw_send((uint8_t *)msg, strlen(msg));
} // y lo enviamos
eb = digitalRead(boton2);
if( eb == HIGH){
msg = "C";
vw_send((uint8_t *)msg, strlen(msg));
}
else {
msg = "D";
vw_send((uint8_t *)msg, strlen(msg));
}
ib = digitalRead(boton3);
if ( ib == HIGH) {
msg = "E";
vw_send((uint8_t *)msg, strlen(msg));
}
else {
msg = "F";
vw_send((uint8_t *)msg, strlen(msg));
}
ob = digitalRead(boton4);
if ( ob == HIGH) {
msg = "G";
vw_send((uint8_t *)msg, strlen(msg));
}
else {
msg = "H";
vw_send((uint8_t *)msg, strlen(msg));
}
}
RECEPTOR:
Diagrama de Flujo:
INICIO
C = A PIN6 = 1
P = C PIN7 = 1
P = E PIN8 = 1
P = G PIN9 = 1
PIN 6, 7, 8, 9 = 0
PROGRAMA:
#include <VirtualWire.h>
int led = 6;
int led2 = 7;
int led3 = 8;
int led4 = 9;
void setup() {
vw_setup(7000);
vw_rx_start();
pinMode(led, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
}
void loop(){
uint8_t msg[VW_MAX_MESSAGE_LEN];
uint8_t len = VW_MAX_MESSAGE_LEN;
if (vw_get_message(msg, &len)){
if ( msg[0] == 'A') {
digitalWrite(led, HIGH);
delay (100);
}
if (msg[0] == 'B'){
digitalWrite(led, LOW);
delay(100);
}
if ( msg[0] == 'C') {
digitalWrite(led2, HIGH);
delay (100);
}
if (msg[0] == 'D'){
digitalWrite(led2, LOW);
delay(100);
}
if ( msg[0] == 'E') {
digitalWrite(led3, HIGH);
delay (100);
}
if (msg[0] == 'F'){
digitalWrite(led3, LOW);
delay(100);
}
if ( msg[0] == 'G') {
digitalWrite(led4, HIGH);
delay (100);
}
if (msg[0] == 'H'){
digitalWrite(led4, LOW);
delay(100);
}
}
CONTROLADOR DE SERVOS (ARDUINO MEGA):
Diagrama de Flujo:
INICIO
PIN6
= 1 AVANZAR
PIN7
= 1 RETROCEDER
PIN8
= 1 DERECHA
PIN9
= 1 IZQUIERDA
PIN 6, 7, 8, 9 = 0
PROGRAMA:
#include <Servo.h>
int pin2 = 2;
int pin3 = 3;
int pin4 = 4;
int pin5 = 5;
int pin6 = 6;
int pin7 = 7;
int pin8 = 8;
int pin9 = 9;
int valor6 = 0;
int valor7 = 0;
int valor8 = 0;
int valor9 = 0;
Servo servo20;
Servo servo21;
Servo servo22;
Servo servo24;
Servo servo26;
Servo servo28;
Servo servo30;
Servo servo32;
Servo servo34;
Servo servo36;
Servo servo38;
Servo servo40;
Servo servo42;
Servo servo44;
Servo servo46;
Servo servo48;
Servo servo50;
Servo servo52;
void setup() {
pinMode(pin2, OUTPUT);
pinMode(pin3, OUTPUT);
pinMode(pin4, OUTPUT);
pinMode(pin5, OUTPUT);
pinMode(pin6, INPUT);
pinMode(pin7, INPUT);
pinMode(pin8, INPUT);
pinMode(pin9, INPUT);
servo20.attach(20);
servo21.attach(21);
servo22.attach(22);
servo24.attach(24);
servo26.attach(26);
servo28.attach(28);
servo30.attach(30);
servo32.attach(32);
servo34.attach(34);
servo36.attach(36);
servo38.attach(38);
servo40.attach(40);
servo42.attach(42);
servo44.attach(44);
servo46.attach(46);
servo48.attach(48);
servo50.attach(50);
servo52.attach(52);
servo52.write(90);
servo40.write(90);
servo26.write(90);
servo20.write(90);
servo21.write(90);
servo22.write(90);
servo24.write(90);
servo28.write(90);
servo30.write(90);
servo32.write(90);
servo34.write(90);
servo36.write(90);
servo38.write(90);
servo42.write(90);
servo44.write(90);
servo46.write(90);
servo48.write(90);
servo50.write(90);
}
void loop(){
valor6 = digitalRead(pin6); //Adelante
if (valor6 == HIGH) {
digitalWrite(pin2, HIGH);
digitalWrite(pin3, LOW);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
servo52.write(95);
servo50.write(110);
servo48.write(100);
servo40.write(95);
servo38.write(110);
servo36.write(100);
servo26.write(85);
servo28.write(70);
servo24.write(80);
servo22.write(90);
servo34.write(90);
servo46.write(90);
delay(250);
servo50.write(90);
servo48.write(90);
servo38.write(90);
servo36.write(90);
servo28.write(90);
servo24.write(90);
servo22.write(95);
servo34.write(95);
servo46.write(85);
delay(250);
servo22.write(85);
servo21.write(70);
servo20.write(80);
servo34.write(85);
servo32.write(70);
servo30.write(80);
servo46.write(95);
servo44.write(110);
servo42.write(100);
servo52.write(90);
servo40.write(90);
servo26.write(90);
delay(250);
servo20.write(90);
servo21.write(90);
servo30.write(90);
servo32.write(90);
servo44.write(90);
servo42.write(90);
servo52.write(85);
servo40.write(85);
servo26.write(95);
delay(250);
}
else {
digitalWrite(pin2, LOW);
digitalWrite(pin3, LOW);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
valor7 = digitalRead(pin7); //Atras
if (valor7 == HIGH){
digitalWrite(pin2, LOW);
digitalWrite(pin3, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
servo52.write(85);
servo50.write(110);
servo48.write(100);
servo40.write(85);
servo38.write(110);
servo36.write(100);
servo26.write(95);
servo28.write(70);
servo24.write(80);
servo22.write(90);
servo34.write(90);
servo46.write(90);
delay(250);
servo50.write(90);
servo48.write(90);
servo38.write(90);
servo36.write(90);
servo28.write(90);
servo24.write(90);
servo22.write(85);
servo34.write(85);
servo46.write(95);
delay(250);
servo22.write(95);
servo21.write(70);
servo20.write(80);
servo34.write(95);
servo32.write(70);
servo30.write(80);
servo46.write(85);
servo44.write(110);
servo42.write(100);
servo52.write(90);
servo40.write(90);
servo26.write(90);
delay(250);
servo20.write(90);
servo21.write(90);
servo30.write(90);
servo32.write(90);
servo44.write(90);
servo42.write(90);
servo52.write(95);
servo40.write(95);
servo26.write(85);
delay(250);
}
else{
digitalWrite(pin2, LOW);
digitalWrite(pin3, LOW);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
valor8 = digitalRead(pin8); //Derecha
if (valor8 == HIGH){
digitalWrite(pin2, LOW);
digitalWrite(pin3, LOW);
digitalWrite(pin4, HIGH);
digitalWrite(pin5, LOW);
servo52.write(95);
servo50.write(110);
servo48.write(100);
servo40.write(95);
servo38.write(110);
servo36.write(100);
servo26.write(95);
servo28.write(70);
servo24.write(80);
servo22.write(90);
servo34.write(90);
servo46.write(90);
delay(250);
servo50.write(90);
servo48.write(90);
servo38.write(90);
servo36.write(90);
servo28.write(90);
servo24.write(90);
servo22.write(85);
servo34.write(85);
servo46.write(85);
delay(250);
servo22.write(95);
servo21.write(70);
servo20.write(80);
servo34.write(95);
servo32.write(70);
servo30.write(80);
servo46.write(95);
servo44.write(110);
servo42.write(100);
servo52.write(90);
servo40.write(90);
servo26.write(90);
delay(250);
servo20.write(90);
servo21.write(90);
servo30.write(90);
servo32.write(90);
servo44.write(90);
servo42.write(90);
servo52.write(85);
servo40.write(85);
servo26.write(85);
delay(250);
}
else{
digitalWrite(pin2, LOW);
digitalWrite(pin3, LOW);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
valor9 = digitalRead(pin9); //Izquierda
if (valor9 == HIGH){
digitalWrite(pin2, LOW);
digitalWrite(pin3, LOW);
digitalWrite(pin4, LOW);
digitalWrite(pin5, HIGH);
servo52.write(85);
servo50.write(110);
servo48.write(100);
servo40.write(85);
servo38.write(110);
servo36.write(100);
servo26.write(85);
servo28.write(70);
servo24.write(80);
servo22.write(90);
servo34.write(90);
servo46.write(90);
delay(250);
servo50.write(90);
servo48.write(90);
servo38.write(90);
servo36.write(90);
servo28.write(90);
servo24.write(90);
servo22.write(95);
servo34.write(95);
servo46.write(95);
delay(250);
servo22.write(85);
servo21.write(70);
servo20.write(80);
servo34.write(85);
servo32.write(70);
servo30.write(80);
servo46.write(85);
servo44.write(110);
servo42.write(100);
servo52.write(90);
servo40.write(90);
servo26.write(90);
delay(250);
servo20.write(90);
servo21.write(90);
servo30.write(90);
servo32.write(90);
servo44.write(90);
servo42.write(90);
servo52.write(95);
servo40.write(95);
servo26.write(95);
delay(250);
}
else{
digitalWrite(pin2, LOW);
digitalWrite(pin3, LOW);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
}
CONCLUSIONES:
Me ha gustado mucho el compendio de acciones llevadas a cabo para la
consecución del robot. Los objetivos alcanzados han sido la realización de:
Streaming en tiempo real Con la Raspberry Pi.
Funcionamiento Correcto de los modulos de RF.
Locomocion del Robot.
REFERENCIAS BIBLIOGRAFICAS:
-Diseño e implementación de un robot móvil hexápodo Alejandor Arango S.
-Desarrollo de Proyecto RPi. TEC Bolivia
-Robot Hexapodo Spidi Rodrigo Garcia.
-Diseño de un Robot Hexapodo Juan Antonio Fernandez Madrigal.
ANEXOS:
