Proyecto g.i.d.e.o.n

1
Reynosa, Tamaulipas Junio del 2017
Proyecto G.I.D.E.O.N
DGETI
Centro de Bachillerato Tecnológico industrial
y de servicios No. 7
Especialidad: Mecatrónica
Submodulo:
Integra e interpreta dispositivos en sistemas mecatrónicos.
Turno: Matutino Grado: 6
Profesor: Ing. Sánchez Ureño Oscar
Integrantes:
Pérez Valdez Alan Martin
Villareal Nava Héctor Eduardo
Martínez Sosa Luis Diego
Benito Galindo Manuel
Silva Sánchez José Alberto
Salvador Carmona Felipe de Jesús

2
Indice
INTRODUCCIÓN.....................................................................................................................4
OBJETIVOS .............................................................................................................................6
DESARROLLO DEL PROYECTO: CAPITULO UNO ..................................................................7
1.0 – Programación .......................................................................................................7
1.1 – Concepto de programación..........................................................................8
1.2 – Arduino...................................................................................................................8
1.2.1 – AT-Mega 2560 R3..........................................................................................9
1.2.2 – IDE Arduino “Sintaxis Básica” .................................................................9
SINTAXIS BÁSICA.................................................................................................................11
Delimitadores................................................................................................................11
Comentarios..................................................................................................................11
Cabeceras......................................................................................................................11
Operadores aritméticos .............................................................................................11
Operadores compuestos...........................................................................................11
ESTRUCTURA DE CONTROL......................................................................................12
Bucles.............................................................................................................................12
Constantes ....................................................................................................................13
Tipos de datos..............................................................................................................13
Tiempo............................................................................................................................14
1.3 – Control de dirección de motores.......................................................................15
Control de motor DC con puente H ........................................................................16
1.3.1 – L293D.............................................................................................................17
DIAGRAMA ESQUEMÁTICO DEL INTEGRADO.......................................................18
1.4 – Sensores ..................................................................................................................19
1.4.1 – Luz: Fotocelda.............................................................................................19
1.4.2 – Distancia: HC-SR04.....................................................................................20
1.4.3 – Humedad/Temperatura: DHT11.................................................................21

3
1.5 – Comunicación.........................................................................................................21
1.5.1 – Modulo HC-05...............................................................................................22
1.6 –Transmisión en vivo (Streaming) .......................................................................23
1.6.1 – Cámara..........................................................................................................23
1.6.2 Como transmitir................................................................................................24
1.6.3 Programa en arduino....................................................................................25
DESARROLLO DEL PROYECTO: CAPITULO DOS ...................................................................44
2.0 –ENSAMBLE DEL VEHÍCULO...........................................................................................44
2.1.1 – ISIS: Diagrama esquemático del vehículo...........................................46
2.2 – Armado del chasis.............................................................................................46
2.2.1 – Base................................................................................................................46
2.2.2 – Carcaza:.........................................................................................................47
2.2.3 – ARES: Diseño de la placa PCB .................................................................49
CONCLUSIONES....................................................................................................................50
ANEXOS.................................................................................................................................51
CODIGO, VISUAL STUDIO ......................................................................................................51
CODIGO ARDUINO ......................................................................................................55
BIBLIOGRAFÍAS.....................................................................................................................64

4
INTRODUCCIÓN
“La robótica va unida a la construcción de "artefactos" que trataban de
materializar el deseo humano de crear seres a su semejanza y que al
mismo tiempo lo descargasen de trabajos tediosos.”
Visto en una escala mayor, la creación de este tipo de robots exploradores
es más una herramienta de investigación para nosotros como simples
mortales podamos conocer más sobre nuestro entorno ya sea en nuestro
mismo planeta o fuera de él.
Es por eso que el ser humano construye artefactos para poder hacer así su
vida más cómoda.
Hoy en día se encuentran en desarrollo proyectos innovadores acerca de
vehículos no tripulados o transportes de “servicio especial” el cual su uso no
sorprende solamente en el hecho de que tras ser diseñados no necesitan de
una persona para ser controlados, sino que son vehículos capaces de tomar
decisiones por si solos además de contar con la posibilidad de atravesar
diversos ambientes y llegar a zonas donde las personas no podrían
maniobrar.
El siguiente proyecto nos permitirá conocer una pequeña parte acerca del
funcionamiento de este
Para realizar el control automático del vehículo, utilizaremos un sensor
ultrasónico como detector de proximidad conectado a una placa Arduino AT-
Mega 2560 R3.
Estos sensores ultrasónicos o de ultrasonido tienen un alto uso en la
Electrónica al utilizarse como detectores de proximidad, midiendo el tiempo

5
que pasa entre la emisión de un sonido y la percepción del eco, calculando
y estableciendo una distancia a la que se encuentra un obstáculo que ha
producido el rebote de la onda sonora.
Y en adición, podremos monitorear los datos recopilados por nuestra foto-
resistencia y por nuestro sensor de humedad/temperatura.

6
OBJETIVOS
GENERAL
- Construir un pequeño vehículo no tripulado que detecte obstáculos
por medio de un sensor ultrasónico utilizando software Arduino.
- El control manual del vehículo a través de visual studio
ESPECIFICO
- Poner en práctica los conocimientos adquiridos en el semestre acerca
de la programación de micro controladores.
- Programar un micro-controlador que garantice una correcta función
del sensor y desplazamiento del vehículo.
- Comprender el funcionamiento de componentes claves del proyecto
o Sensor ultrasónico HC-SR04
o Modulo bluetooth
o Encapsulados LS293D
o Arduino AT-Mega 2560 R3
o Sensor de Humedad y temperatura DHT11
o La forma de transmitir en tiempo real desde la Go Pro+
o El funcionamiento a través de Visual Studio
- Crear un circuito PCB que permita la correcta función de los
componentes

7
DESARROLLO DEL PROYECTO: CAPITULO UNO
1.0 – Programación
Siempre se ha estado consciente de que el hombre está en la obligación de
realizar un número grande de actividades constantemente para llevar su
vida con normalidad o estabilidad.
El desarrollo de la tecnología a lo largo de los años ha logrado un mayor
grado de productividad en la vida del mismo. Momento en el cual todos
hemos notado que la cantidad de tareas manuales ha sido sustituida por el
trabajo llevado a cabo mediante maquinas. Con el desarrollo de las
primeras computadoras ya no solo el trabajo físico fue remplazado por
maquinas, sino también el trabajo intelectual. La rápida evolución de las
computadoras permite realizar cada vez con mayor poder cifras de grandes
cálculos complejos ya que tienen la posibilidad de procesar y generar datos
para el beneficio de quien la controla... Programación es la adaptación de
nuestro potencial sobre una máquina, para la solución de problemas ante el
beneficio del hombre.
La programación en este caso estará divida en 2 ramas:
 Programación de arduino.
 Programación en visual.
Comenzaremos con la programación de arduino, si conocen del tema,
discúlpennos pero explicaremos todo, paso a paso, espero y no sea tedioso
para ustedes.

8
1.1 – Concepto de programación
La programación tiene una definición sencilla, que a la vez puede resultar
compleja para muchos cuando se adentran a un entorno en particular, la
forma más entendible de la palabra “Programación” es: proceso en el cual
un programa o aplicación es desarrollado”. Todo esto refiriéndose al
funcionamiento de un conjunto de instrucciones o pasos escritos para llevar
a cabo una tarea específica.
1.2 – Arduino
La compañía de Hardware Libre Arduino desarrolla la placa que usaremos
en este proyecto la cual consiste en un circuito impreso con un micro-
controlador AT-Mega 2560 desarrollado por la compañía ATMEL, la cual es
fabricante de los micro-controladores de sus demás placas.
Esta compañía cuenta también con software gratuito el cual necesitaremos
para programar nuestra placa y que está basado en el entorno de desarrollo
“Processing” y en el lenguaje de programación “Wiring”.
El micro-controlador es programado mediante un PC, haciendo uso de
comunicación serial mediante un convertidor de niveles RS-232 a TTL serial.
Hemos elegido usar este entorno de desarrollo por su fácil disponibilidad y
costo accesible, además de ser un software ideal para desarrollo de objetos
interactivos autónomos (no olvidemos el objetivo general del proyecto).
Uno de los microcontroladores más baratos y de fácil entendimiento en el
mercado actual, empezaremos con el tipo de arduino que utilizaremos ya
que esta marca cuenta con diversos tipos para que tu encuentres el que
más te convenga.

9
1.2.1 – AT-Mega 2560 R3
En este caso usaremos el AT-Mega, uno de los arduinos más básicos con el
que podemos realizar conexiones electrónicas, gracias a su gran cantidad
de pines disponibles, es perfecto para este proyecto
El Arduino Mega 2560 es una placa basada en el micro controlador AT-
Mega 2560. Como características destacables podemos decir que tiene 54
pines de entrada y salida digital (de los cuales 14 de ellos son salidas PWM),
16 entradas analógicas y 4 receptores/transmisores serie TTL-UART.
Consta de una memoria flash de 256 Kilobytes (de los cuales 8 están
reservados para el bootloader), una memoria SRAM de 8 KB y una
EEPROM de 4 KB. Su voltaje de trabajo es igual al del modelo UNO: 5V
Esta placa es compatible con los Shield de anteriores modelos como el
Arduino UNO, Arduino Duemilanove y Diecimila.
1.2.2 – IDE Arduino “Sintaxis Básica”
Para poder comprender el aspecto principal de este proyecto, es necesario
dar un repaso lo que hemos visto sobre los conceptos básicos de un
programa en Arduino.
Como ya mencionamos, Arduino esta originalmente basado en Processing y
Wiring pero en si estos lenguajes están estrechamente ligados a funciones
estándar del C y algunas del C++.
La estructura básica de un programa de Arduino consta de dos partes
necesarias o funciones, las cuales encierran bloques que contienen
declaraciones, estamentos o instrucciones.

10
En la imagen, “setup() { “ es la parte que se encarga de inicializar los modos
de trabajo de los pines que se usaran de la placa y “loop() { “ es la parte del
programa que se ejecutara repetida o cíclicamente (de ahí el termino loop –
bucle) ambas funciones son necesarias para que el programa trabaje. El
siguiente código es un ejemplo de un led parpadeante.

11
SINTAXIS BÁSICA
Delimitadores
- ; Los puntos y coma sirven para marcar el final de una instrucción.
- , Las comas se utilizan para separar elementos en una instrucción.
- {} Las llaves sirven para definir un conjunto de instrucciones.
Comentarios
- // Las diagonales permiten colocar comentarios en un renglón
- /* */ La diagonal con asterisco permite colocar comentarios en un
sinfín de renglones.
Cabeceras
- #define se usa para definir el valor de una variable, por lo tanto lo que
se coloque aquí
No podrá cambiar en el transcurso del programa.
- #include se usa para incluir alguna librería que facilite la escritura del
programa.
Operadores aritméticos
- + sirve para sumar, - sirve para restar, * sirve para multiplicar, / sirve
para dividir
Operadores compuestos
- ++ incremento de uno
- -- decremento de uno
- += incremento en x
- -= decremento en x
- *= multiplicación en x
- /= división en x

12
ESTRUCTURA DE CONTROL
Condicionales
- If.- sirve para ejecutar una instrucción siempre y cuando SE CUMPLA
una condición.
- else.- sirve para ejecutar una instrucción si NO SE CUMPLE la
condición.
- switch / case funciona como un if, excepto que este ejecuta varias
instrucciones dependiendo el valor que tome la variable en el
transcurso del programa
Bucles
- for se usa para repetir un bloque de sentencias encerradas entre
llaves un número determinado de veces mediante una expresión.
Esta función separa cada término por medio d un punto y coma.

13
El siguiente ejemplo inicia un entero en 0 y la condición es probar que es
menor o igual que 20, si es así el entero incrementara en uno y se vuelven a
ejecutar las instrucciones que hay dentro de las llaves. Ejemplo para
configurar varios pines como salidas:
- while es un bucle que ejecuta instrucciones cuando una variable tiene
un valor, es casi una combinación de un if con un for.
Constantes
- HIGH / LOW representan los niveles alto y bajo de las señales de
entrada y salida. Los niveles altos son aquellos de 3 volts o más.
- INPUT / OUTPUT entrada o salida
- false / true señales que representan el cero lógico (en el caso de
“false”) o cualquier numero entero diferente de cero (en el caso de
“true”)
Tipos de datos
- byte almacena un valor numérico de 8 bits sin decimales en un rango
de 0 a 255.
- int almacena un valor numérico de 16 bits sin decimales en un rango
de -32,767 a 32,767.

14
- long almacena un valor numérico de 32 bits sin decimales en un
rango de -2147483647 a
2147483647.
- float almacena un valor numérico de mayor resolución que los de 32
bits con un rango comprendido entre 3.4028235E+38 a +38-
3.4028235E.
Tiempo
- delay() detiene la ejecución del programa la cantidad de tiempo que
se le indique dentro del paréntesis.

15
1.3 – Control de dirección de motores
En este apartado trataremos solamente motorreductores de corriente directa
ya que no se requiere el uso de servos ni de motores paso a paso ya que la
medición será llevada a cabo mediante un sensor.
La característica principal de estos motores es un giro medianamente rápido
pero ideal para un giro controlado y soporte de peso ya que los
motorreductores son generalmente usados para mover peso.

16
Control de motor DC con puente H
Mediante este circuito se puede controlar el giro de los motores de corriente
directa (motor DC), el circuito sirve para controlar motores de mediana
potencia.
El sentido del giro depende del nivel del voltaje tanto como avance o
retroceso.

17
Si el voltaje en la parte que marca “AVANCE” llegara el transistor Q1 se
satura y hace que fluya corriente al Q2 y Q5, cuando estos se saturan
hacen que el motor gire hacia un sentido.
Si el voltaje en la parte que marca “RETROCESO” llega al transistor Q6 se
satura y hace que fluya corriente al Q3 y Q4, cuando estos se saturan
hacen que el motor gire hacia el sentido contrario.
Este circuito usa diodos para la protección de los transistores debido al
cambio de polaridad en las bobinas del motor.
(Esta tabla indica que tipo de entrada y salida de los motores)
1.3.1 – L293D
El integrado L293D consta de cuatro circuitos que permiten el manejo de
cargas de potencia media, en especial para 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 hasta 36 V.
Los circuitos individuales se pueden usar de manera independiente para
controlar cargas de cualquier tipo y, en el caso de ser motores, manejar un
único sentido de giro. Pero además, cualquiera de estos cuatro circuitos
sirve para configurar la mitad de un puente H.
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.

18
DIAGRAMA ESQUEMÁTICO DEL INTEGRADO

19
1.4 – Sensores
Utilizaremos tres sensores distintos en este proyecto, el principal hará que
nuestro vehículo pueda esquivar los obstáculos que aparezcan al avanzar,
el segundo se encargara de iluminar para avanzar en la oscuridad y el
tercero se encargara de entregarnos valores para humedad y temperatura,
así es damas y caballeros, es un sensor DH11. Antes que nada debemos
dar un vistazo al concepto de lo que es un sensor:
Los sensores son objetos que son capaces de detectar objetos, condiciones,
además de magnitudes físicas o químicas, llamadas variables de
instrumentación, y transformarlas en variables eléctricas. Las variables de
instrumentación pueden ser por ejemplo: luz, temperatura, humedad,
distancia, aceleración, inclinación, presión, desplazamiento, fuerza, torsión,
color, movimiento, entre muchas otras. Una magnitud eléctrica puede ser
una resistencia eléctrica (como en una RTD), una capacidad eléctrica (como
en un sensor de humedad), una tensión eléctrica (como en un termopar),
una corriente eléctrica (como en un fototransistor), etc.
1.4.1 – Luz: Fotocelda
Una fotocelda es una resistencia variable, cuyo valor aumenta o disminuye
con el aumento de intensidad de luz que caiga sobre él. Puede también ser
llamado fotorresistor, fotoconductor, célula fotoeléctrica o resistor
dependiente de la luz, cuyas siglas, LDR, se originan de su nombre en
inglés light-dependent resistor. Su cuerpo está formado por una célula
fotorreceptora y dos patillas. Este sensor será usado para poder encender
dos LEDs que se encargaran de iluminar el camino del vehículo cuando
este transite en la noche.
La variación del valor de la resistencia puede tener cierto retardo al
momento de cambiar de oscuro a luminoso o de luminoso a oscuro.

20
1.4.2 – Distancia: HC-SR04
Sensor de ultrasonido económico y preciso HC-SR04. Su relación de
costo/beneficio lo hace óptimo para un gran abanico de aplicaciones. El uso
de este módulo es bastante sencillo debido a que se toda la electrónica de
control, transmisión y recepción se encuentra contenida en PCB. El usuario
solamente debe enviar un pulso de disparo y medir en tiempo alto del pulso
de respuesta. Solamente se requieren 4 hilos para completar la interfaz con
el módulo de sensor HC-SR04.

21
1.4.3 – Humedad/Temperatura: DHT11
Es un sensor de temperatura muy económico y muy utilizado por los
amantes de la electrónica y los microcontroladores como Arduino.
El DHT11 es un sensor que proporciona una salida de datos digital.
No todo es bueno para este sensor:
 Entre las desventajas pues, el DHT11 solo lee enteros, no podemos
leer temperaturas con decimales por lo que tenemos que pensarlo
muy bien a la hora de utilizar este sensor para trabajos en los que se
requieran lecturas precisas de temperatura y/o humedad.
Pero es preciso para lo que necesitamos ahora, si requieren de uno más
preciso tendrán que investigar cual será el de mayor utilidad para ustedes.
1.5 – Comunicación
La comunicación es importante en el proyecto, ya que se necesita un medio
por el cual el vehículo pueda configurarse una forma autónoma y otra
remota, esto para cuando sea necesaria una maniobrabilidad controlada y
no por medio de un sensor.
El bluetooth es una opción económica y sencilla de programar para este
proyecto además de facilitar comunicaciones entre equipos móviles y
eliminar los cables y conectores entre estos.
Los dispositivos que con mayor frecuencia utilizan esta tecnología
pertenecen a sectores de las telecomunicaciones y la informática personal,
como PDA, teléfonos móviles, computadoras portátiles, ordenadores
personales, impresoras o cámaras digitales.

22
1.5.1 – Modulo HC-05
El módulo de comunicación bluetooth HC-05 es un componente fácil de usar
además de estar diseñado para la configuración de la conexión serie
inalámbrica transparente.
El módulo del puerto serial de Bluetooth está plenamente cualificado
Bluetooth V2.0 + EDR (Enhanced Data Rate) Modulación de 3 Mbps con
total transceptor de radio de 2,4 GHz y la banda base. Utiliza RSE Bluecore
sistema Bluetooth solo chip 04-externa con tecnología CMOS y con AFH
(Adaptive Frequency Hopping Feature). Tiene la huella de tan pequeño
como 12.7mmx27mm. Espero que va a simplificar su ciclo global del diseño
/ desarrollo.

23
1.6 –Transmisión en vivo (Streaming)
Todo carro explorador que se respete debe tener la capacidad de hacer
videos o de transmitirlos en vivo, nuestro proyecto tiene la capacidad de
transmitirlos con un retraso de máximo 3 segundos.
-Representación de transmisión stream
1.6.1 – Cámara
En este caso utilizaremos una cámara bastante cara, pero como nosotros la
teníamos en nuestro poder desde antes de la planeación del proyecto es
por eso que usaremos esta, para no comprar otra.
La cámara es una Go PRO +

24
1.6.2 Como transmitir
Muy bien ha llegado la hora que muchos esperaban, ¿no?
La verdad es que no es una transmisión directa GoPro – PC, si no, que
hacemos unas “escalas” en la transmisión.
Lo primero que hacemos es transmitir lo que ve la cámara y capturarlo en la
computadora por medio de una aplicación llamada “Capture” esta aplicación
lo que hará es transmitir tu video de la GoPro al celular.
Después, tenemos que transmitir del celular al programa para reproducir
videos VLC, (las versiones del 2.0.0 en adelante sirven bien).
Una vez que la transmisión que tengamos este en VLC, lo mandaremos a
Visual Studio. (Esta parte continuara en la programación).
-Imagen de GoPro

25
1.6.3 Programa en arduino
A continuación, se procederá a dar una explicación del código que se
escribirá parte por parte:
#include <SoftwareSerial.h>
SoftwareSerial Mod(50,51); // RX | TX
#include <AFMotor.h>
AF_DCMotor motor1(1);
#include <rDHT11.h>
int rDHT11pin = A14;
rDHT11 DHT11(rDHT11pin);
Esta es la parte inicial del código que nos permite agregar librerías para
permitirnos el control de ciertos comandos como podemos apreciar en la
imagen 1.1 donde se aprecia la parte de los ‘#incluede <SoftwareSerial.h>’
en esa instrucción se está mandando a llamar la instrucción específica del
uso de un serial para el uso del software para activarlo, después se
programa un tiempo para que se active.
En la parte de #incluede<AFMotor.h> se puede apreciar que se están
definiendo cuatro motores y a cada uno de ellos se le está dando un nombre
específico para que se pueda utilizar específicamente.
Y en la parte de #incluede<rDHT11.h> se está dado la instrucción que va a
ocupar el sensor de temperatura y humedad sin esta parte no podría
funcionar el sensor y es necesario descargarlo de la internet para poder
agregarlo en el programa de Arduino.

26
int ilu;
char Var; //Variable que almacena el carácter de bluetooth
int vel=255; //velocidad de motores
int decision=0; //decisión que tomara el carro al dar vuelta al detectar un
obstáculo
int y; //variable para modalidades
int echo=45;
int trig=44;
int duracion;
int distancia;
int lti = 48; //luz trasera izquierda
int ltd = 49; //luz trasera derecha
int ftr; //fotoresistencia
int lad=52; //luz automática derecha
int lai=53; //luz automática izquierda
int dd = 35; //direccional derecha
int di = 37; //direccional izquierda
int buzzer1 = 21; //pin positivo buzzer
int buzzer2 = 18; //pin negativo del buzzer
long a=0;
long d=0;
long c=0;
long b=100000000000;
long humedad;
En esta parte se empieza a declarar funcionalidades y para que inicie el
desarrollo de las instrucciones para poder empezar a darle funcionalidad,
para que los elementos empiecen a trabajar según sea lo que se le está
declarando, como se puede apreciar que a cada lado de la instrucción se
describe la acción que está realizando y también se puede observar en que
pines se están conectando.

27
void setup(){
pinMode (22,OUTPUT); //Pin negativo del sensor humedad
digitalWrite(22,0);
pinMode (lad,OUTPUT);
pinMode (lai,OUTPUT);
pinMode(lti, OUTPUT);
pinMode(ltd, OUTPUT);
pinMode(di, OUTPUT);
pinMode(dd, OUTPUT);
pinMode(trig, OUTPUT);
pinMode(buzzer1, OUTPUT);
pinMode(echo, INPUT);
pinMode(A15, INPUT);
Mod.begin(38400); //Comunicación con el Modulo
Serial.begin(9600); //comunicación con el puerto de serie
Serial.println("Encendido");
motor1.setSpeed(vel);
}
En esto se empieza a desarrollar lo que es la parte de cada elemento, como
se podrá observar en cada línea tiene descrito para qué es, los pinMode,
son los pines del Arduino en esa parte a cada uno se le va declarando si es
una ‘entrada’ o ‘salida’ y l el Mod.begin eso es un comando que está
activando un modo de inicio del componente en la programación en esta
parte el Serial.begin está creando la activación de una comunicación del
sistema con el componente electrónico para que empiece a enlazarse, el
Serial.println con esta instrucción lo que está haciendo es que revele un
mensaje de carácter entendible al y muestre lo que se le está programando
en el tiempo que se le solicite, los motor1.setSpeed, motor2,3 y 4 son
comando para que los motores reductores reciban la señal de activación y
también se declara a cada pin para que se pueda a volver a usar si es
necesario.

28
void loop(){
if(Mod.available()>0)//Detectar datos en el modulo
if(Serial.available()>0) //Detectar datos en el serial
Mod.write(Serial.read()); //Ejecutar dato recibidos serial
Var = Mod.read();
a=millis();
luces_automaticas();
if( Var == 'F' ){
y=1;
detener();
Serial.println("FUNCION REMOTA ACTIVADA...");
b=a+5000;
}
if(y==1){
sensores();
control_remoto();
}
if( Var == 'G' ){
Serial.println("APAGADO");
digitalWrite (lti,0);
digitalWrite (ltd,0);
y=0;
detener();
b=0;
c=0;
d=0;
}
if( Var == 'H' ){
Serial.println("FUNCION AUTONOMA ACTIVADA...");
detener();
delay(1000);
y=2;
}
if(y==2){
autonomo();
}

29
if( Var == 'P' ){
Serial.println("ENLAZADO");
y=3;
}
if(y==3){
y=0;
}
}
En este punto del código se empieza a darle lógica a lo comando usados
anteriormente para que empiecen a trabajar en conjunto y realicen las
tareas que se le están asignando, el ‘Var = Mod.read();’ es la instrucción
que se declarara como variable para que se pueda usar como instrucción en
los casos que sean necesarios, en esto el ‘a=millis();’ se utiliza en lugar de
los delay que vienen siendo pausas pero en cambio del delay el millis no
realiza las pausas totalmente aun permite el flujo de voltaje en los
componentes y así se evita una falla de los componentes y el sistema del
código, esto ‘detener();’ no ayuda a crear un espacio para la instrucción que
se le da como nombre lo que va realizar y sirve para que nos ahorremos
unos cuantos renglones de código, no importa cómo le quieras llamar, esta
instrucción ‘if(y==2)’ nos ayuda a determinar cuándo se quiere realizar o
activar una función específica sirviendo como operador lógico que analiza
cuando la instrucción es falsa o verdadera y dependiendo que sea el caso
hará lo que necesite hacer.

30
void control_remoto(){
switch (Var){
case 'W':
avance();
Serial.println("AVANCE");
break;
case 'A':
vuelta_izquierda();
Serial.println("IZQUIERDA");
break;
case 'D':
vuelta_derecha();
Serial.println("DERECHA");
break;
case 'S':
reversa();
Serial.println("REVERSA");
break;
case 'E':
detener();
Serial.println("ALTO");
break;
}
}
En esta parte se empieza a crear un bloque de comando únicamente para
el control manual de carro explorador y es necesario de casos que activen
ciertas funciones y para eso tenemos a los ‘switch case’ esto nos permite
que por medio de teclas declaradas activen comando y a su vez desactiven
otros comandos según sea lo que se le declaro dentro de cada ‘switch case’,
como se puede observar en la parte de arriba lo que se esta haciendo es
que ciertos botones con ciertas letras van a activar a los motores y se les
darán una instrucción de lo que deben de realizar ya sea avanzar o
retroceder

31
void autonomo(){
avance();
decision++;
if(decision==3){
decision=1;
}
digitalWrite(trig, LOW);
delayMicroseconds(2);
digitalWrite(trig, HIGH); //genera el pulso de triger por 10ms
duracion = pulseIn(echo, HIGH);
distancia = (duracion/2) / 29; //calcula la distancia en centimetros
if (distancia <= 30 && distancia > 15){
Serial.println("obstaculo detectado");
digitalWrite(buzzer1,1);
detener(); delay(500);
decisiones();
}
if (distancia < 15 && distancia >= 0){
reversa(); delay(500);
decisiones();
}
}

32
En este bloque podemos apreciar que se creó para el control autónomo del
carro explorador esto quiere decir que el carro por medio de las
instrucciones dadas podrá conducirse por sí solo y será capaz de tomar sus
propios caminos, como se ver hay una parte que dice ‘delayMicroseconds’
esto nos ayuda que ocurra una pausa no total de todo el sistema con el
equipo como por ejemplo a la hora de detectar un obstáculo el carro tomara
la decisión de irse por otro camino que más le convenga y a la hora que
detecte un obstáculo mandara una señal y por medio de un buzzer liberara
una señal audible que nos avisara que detecto un obstáculo y que va a
cambiar de sentido según sea lo que el sistema haya decidido y el sensor
ultrasónico determinara que lado está despejado y así poder escoger la
dirección hacia donde ira
}
void decisiones(){
if(decision==1){
Serial.println("decision derecha");
vuelta_derecha(); delay(1000);
}
if(decision==2){
Serial.println("decision izquierda");
vuelta_izquierda(); delay(1000);
}
}
void avance(){
digitalWrite (di,0);
digitalWrite (dd,0);
motor1.run(FORWARD); //Recuerda (FORWARD = ADELANTE) –
(BACKWARD = ATRAS) – (RELEASE = DETENER)
motor2.run(FORWARD);
motor3.run(BACKWARD); //Recuerda (FORWARD = ADELANTE) –
motor4.run(BACKWARD);
}

33
Como se puede analizar se podrá ver que esto es parte del control
autónomo del carro y es aquí donde se tomaran las decisiones dependiendo
del sensor que detecte será el comando que mandara como respuesta
hacia el Arduino, para poder crear esta parte se necesita del if, que nos
permitirán analizar los casos y cuando resulten verdaderos será cuando
actúe el if y así será llamado el caso que se solicite según la que se
programó, como se observa después de los if se encuentra el control de los
motores reductores y es ahí cuando un caso resulte verdadero activara a los
motores y comenzara a moverse.
void vuelta_izquierda(){
motor3.run(RELEASE); //Recuerda (FORWARD = ADELANTE) –
}
void vuelta_derecha(){
motor2.run(RELEASE);
}

34
void reversa(){
}
void detener(){
if((y==1 || y==2)){
}
}
Como se podrá apreciar aún se sigue con la parte autónoma del carro y en
esta parte son las instrucciones que podrá tomar por si solo el carro
claramente basándose en su código de que se le fue asignado en su
desarrollo inicial y así, como se observó anteriormente arriba se observa
que puede avanzar o retroceder a la que el sensor detecte que sea
necesario y así será necesario activar los motores reductores y darles la
orden que giren según lo necesite para poder continuar con el trayecto que
se propuso el sistema.

35
void luces_automaticas(){
ftr=analogRead(A15);
if((ftr<300)|| (y==0)){
digitalWrite(lad,0);
digitalWrite(lai,0);
}
if(((ftr>=300) && (y==1))||((ftr>=500) && (y==2)))
{
}
ilu = map(ftr, 1023, 0, 0, 11);
}
Este bloque se creó para que la iluminación del carro con la que cuenta sea
totalmente automática y dependan cien por ciento de la fotorresistencia para
que no suceda un desgaste innecesario de la batería y así sea más óptimo
el uso de la batería, cuando el carro se encuentre en lugares con ausencia
de luz solar la fotorrestencia entrara en acción y mandara una señal a su
bloque y está por medio de una toma de decisión autónoma mandara voltaje
a las salidas del pin de los led´s y así se iluminara el camino en donde está
recorriendo .

36
void sensores(){
if (a==b+100)
{
c=a+200;
Mod.write(ilu);
b=0;
}
if (a==c+100)
{
d=a+200;
humedad = DHT11.update();
Mod.write(DHT11.getHumidity());
c=0;
}
if (a==d)
{
b=a+200;
Mod.write(DHT11.getCelsius());
d=0;
}
}

37
Y al final este bloque es un conjunto de enlazados para los sensores con los
que cuenta el carro y así puedan trabajar juntos con una armonía que les
permitan funcionar al cien por ciento, el ‘DHT11.update();’ esta función es la
que nos permite usar el sensor de humedad junto con el de temperatura y
así nos pueda reflejar en pantalla los datos que se le solicitan, lo demás
están basado en casos de if que están esperando a que se presenten
instrucciones verdaderas y en el momento que suceda actúan según fueron
programados.
Hasta aquí finaliza el código completo junto con su descripción y sus
funcionalidades explicadas lo mejor posibles para cada lector que desee
conocer más sobres proyectos de tipo prototipos

38
1.6.4 Programación en Visual Studio
En este apartado de nuestra grandiosa tesina, explicare las partes que
posiblemente puedan presentar más problemas a la hora de entender si no
llevas mucho tiempo en la programación con visual.
using System.IO.Ports;
Esta es la libreria que usaremos para la conexión serial de arduino a
visual.
System.Windows.Forms.Control.CheckForIllegalCrossThreadCalls
= false;
Esta instrucción nos permite ignorar varias señales malas, sin esta
instrucción posiblemente se nos cerraría visual studio muy seguido.
private void casos()
{
switch (con)
{
case 1:
textilum.Text = (dato_reciv + "0 %");
break;
case 2:
textBox1.Text = (dato_reciv + "%");
break;
case 3:
textBox2.Text = (dato_reciv + "°C");
con = 0;
break;
}
Este “switch-case” le dice al programa a donde mandar la información
recibida a través de los diferentes sensores desde el de iluminación,
temperatura y el de humedad.

39
private void serialPort1_DataReceived(object sender,
SerialDataReceivedEventArgs e)
{
dato_reciv =
(Convert.ToString(serialPort1.ReadByte()));
con++;
casos();
if (con >= 3)
{
con = 0;
}
}
El dato recibido lo lee y lo envie al void donde decidirá a donde llevar esa
lectura.
private void Control_Click(object sender, EventArgs e)
{
textilum.Text = "Cargando...";
textBox1.Text = "Cargando...";
textBox3.Text = "Manual";
serialPort1.WriteLine("F");
z = 1;
}
Este es el void del botón que te permite controlar el robot explorador
manualmente, iguala el valor de z a 1 que lo permitirá si esta en esta opción,
el moverse con las flechas del teclado
private void Automatico_Click(object sender, EventArgs e)
{
z = 0;
serialPort1.WriteLine("H");
textilum.Text="---";
textBox1.Text = "---";
textBox3.Text = "Automatico";
flechasOff();
}
Por otro lado este es el void para pasar a modo automatico donde por
medio del sensor podrá evitar obstáculos.
private void Apagar_Click(object sender, EventArgs e)
{

40
z = 0;
serialPort1.WriteLine("G");
textilum.Clear();
textBox1.Clear();
textBox2.Clear();
textBox3.Text = "Apagado";
flechasOff();
}
En este caso es el botón para apagar el vehículo limpiando la información
que hay en los textbox y bloqueando las teclas.
private void Adelante_Click(object sender, EventArgs e)
{
if (z == 1)
{
Atras.BackgroundImage =
Properties.Resources.logo_4;
Derecha.BackgroundImage =
Properties.Resources.Logo_2;
serialPort1.WriteLine("W");
Adelante.BackgroundImage =
Izquierda.BackgroundImage =
Properties.Resources.Logo;
}
}
Si tenemos el botón de manual activado nuestra z valdrá 1 y entonces
podremos utilizar en este caso el botón de avance, el caso también cambia
la imagen en el visual.
Esto es casi exactamente lo mismo con las otras 3 teclas, si la variable z
vale 1 presionando la tecla te hará lo que está en el case que es cambiar la
imagen y escribir la letra que presionaste.
private void Detener_Click(object sender, EventArgs e)
{
flechasOff();
serialPort1.WriteLine("E");
}
En este boton detenemos el movimiento del carrito, bloqueando las teclas.

41
private void button3_Click(object sender, EventArgs e)
{
url = textBox4.Text;
try
{
webBrowser1.Url = (new Uri(url));
label6.Visible = false;
}
catch
{
textBox4.Clear();
MessageBox.Show("Introduzca nuevamente la
URL deseada");
return;
}
}
Con este boton busca la URL que escribes en el textbox.
private void Form1_KeyDown(object sender, KeyEventArgs e)
{
if ((e.KeyCode == Keys.W) && (x==1))
{
Adelante_Click(sender, e);
}
if ((e.KeyCode == Keys.S) && (x == 1))
{
Atras_Click(sender, e);
}
if ((e.KeyCode == Keys.A) && (x == 1))
{
Izquierda_Click(sender, e);
}
if ((e.KeyCode == Keys.D) && (x == 1))
{
Derecha_Click(sender, e);
}
if ((e.KeyCode == Keys.E) && (x == 1))
{
Detener_Click(sender, e);
}
if ((e.KeyCode == Keys.J) && (x == 1))
{
Control_Click(sender, e);

42
}
if ((e.KeyCode == Keys.K) && (x == 1))
{
Automatico_Click(sender, e);
}
if ((e.KeyCode == Keys.L) && (x == 1))
{
Apagar_Click(sender, e);
}
if (e.KeyCode == Keys.Z)
{
button1_Click(sender, e);
}
if (e.KeyCode == Keys.Escape)
{
}
}
En todo este gran pedazo de código, te preguntaras posiblemente “¿Qué es
lo que se hace con ese código”?
Pues bueno te explico, nuestro proyecto está diseñado para poder
controlarse a través de visual, pero quisimos un poco más y añadimos para
mayor comodidad poder controlarlo por las teclas W A S D.
Y esta sería la interfaz en su vista final, cabe recalcar que lo estético está a
total disposición del programador, tú puedes hacer como quieras la estética.

43
-Imagen de la interfaz.

44
DESARROLLO DEL PROYECTO: CAPITULO DOS
2.0 –ENSAMBLE DEL VEHÍCULO
En esta parte del proyecto estaremos viendo las conexiones físicas del
proyecto, diseño de las placas PCB para los elementos como los sensores,
módulos de comunicación y otros componentes.
Haremos uso de un nuevo software llamado Proteus, el cual nos dará las
herramientas para comprobar el correcto funcionamiento de nuestro
vehículo además de ofrecernos un entorno en el cual nosotros podamos
desarrollar nuestras placas PCB.

45
2.1 –Proteus
-Representación de las conexiones del proyecto
El programa Proteus es una compilación de programas de diseño y
simulación electrónica, desarrollado por Labcenter Electronics que consta
de los dos programas principales: Ares e Isis, y los módulos VSM y Electra.
Estos “Ares e Isis” son los programas que usaremos para el desarrollo del
PCB y de la simulación de nuestro código para poder dar seguimiento al
ensamble del mismo.

46
2.1.1 – ISIS: Diagrama esquemático del vehículo
El Programa ISIS, Intelligent Schematic Input System (Sistema de Enrutado
de Esquemas Inteligente) nos permitirá diseñar los plano eléctricos del
circuito de nuestro vehículo con los componentes que usaremos en el
ensamble físico, desde simples resistencias, hasta los microprocesadores y
sensores, incluyendo fuentes de alimentación, generadores de señales y
elementos de comunicacion.
Los diseños realizados en ISIS son simulados en tiempo real, mediante el
módulo VSM, asociado directamente con ISIS.
Una de las prestaciones de Proteus, integrada con ISIS, es VSM, el Virtual
System Modeling (Sistema Virtual de Modelado), una extensión integrada
con ISIS, con la cual se puede simular, en tiempo real, con posibilidad de
más rapidez; todas las características de varias familias de micro
controladores.
2.2 – Armado del chasis
2.2.1 – Base
Pusimos todo nuestro empeño en realizar la placa base para todo nuestro
proyecto, realizamos por medio de las tácticas aprendidas con la profesora
Briselda de pasar un circuito impreso a las tablillas fenólicas, montamos
todas nuestras tablillas en una placa de acrílico, decidimos usar la placa de
acrílico por su bajo costo y su fácil manejo porque fijamos las tablillas con
silicón caliento, por si ocurría un corto, podíamos fácilmente calentar el
silicón y despegar lo necesario.
Existen varios programas para crear circuitos impresos, fácilmente en
google encontraran uno si así lo desea usted señor lector.

47
Foto de la base
2.2.2 – Carcaza:
Parte de frontal

48
-Parte lateral
-Parte trasera

49
2.2.3 – ARES: Diseño de la placa PCB
ARES, o Advanced Routing and Editing Software (Software de Edición y
Ruteo Avanzado); es la herramienta de enrutado, ubicación y edición de
componentes, se utiliza para la fabricación de placas de circuito impreso,
permitiendo editar generalmente, las capas superficial (Top Copper), y de
soldadura (Bottom Copper).
Ejecutando ARES directamente, y ubicando cada componente en el circuito.
Tener cuidado al DRC, Design Rules Checker (Verificador de Reglas de
DISEÑO).
-Represetacion del circuito en PCB wizard.

50
CONCLUSIONES
En conclusión tenemos que el ser humano es perezoso por naturaleza,
cada invento que el ser humano cree es para satisfacer una necesidad, son
contadas las personas que buscaban un cambio verdadero, por desgracia
este no es un caso de esos, este proyecto lo realizamos por el mero
propósito de obtener una calificación aprobatoria con usted.

51
ANEXOS
CODIGO, VISUAL STUDIO
using System.IO.Ports;
System.Windows.Forms.Control.CheckForIllegalCrossThreadCall
s = false;
private void casos()
{
switch (con)
{
case 1:
textilum.Text = (dato_reciv + "0 %");
break;
case 2:
textBox1.Text = (dato_reciv + "%");
break;
case 3:
textBox2.Text = (dato_reciv + "°C");
con = 0;
break;
}
private void serialPort1_DataReceived(object sender,
SerialDataReceivedEventArgs e)
{
dato_reciv =
(Convert.ToString(serialPort1.ReadByte()));
con++;
casos();
if (con >= 3)
{
con = 0;
}
}
rivate void Control_Click(object sender, EventArgs e)
{
textilum.Text = "Cargando...";

52
textBox3.Text = "Manual";
serialPort1.WriteLine("F");
z = 1;
}
private void Automatico_Click(object sender, EventArgs e)
{
z = 0;
serialPort1.WriteLine("H");
textilum.Text="---";
textBox3.Text = "Automatico";
flechasOff();
}
private void Apagar_Click(object sender, EventArgs e)
{
z = 0;
serialPort1.WriteLine("G");
textilum.Clear();
textBox1.Clear();
textBox2.Clear();
textBox3.Text = "Apagado";
flechasOff();
}
private void Adelante_Click(object sender, EventArgs e)
{
if (z == 1)
{
Atras.BackgroundImage =
Properties.Resources.logo_4;
Derecha.BackgroundImage =
serialPort1.WriteLine("W");
Adelante.BackgroundImage =
Izquierda.BackgroundImage =
Properties.Resources.Logo;
}
}
private void Detener_Click(object sender, EventArgs
e)

53
{
flechasOff();
serialPort1.WriteLine("E");
}
private void button3_Click(object sender, EventArgs e)
{
url = textBox4.Text;
try
{
webBrowser1.Url = (new Uri(url));
label6.Visible = false;
}
catch
{
textBox4.Clear();
MessageBox.Show("Introduzca nuevamente la
URL deseada");
return;
}
}
private void Form1_KeyDown(object sender, KeyEventArgs e)
{
if ((e.KeyCode == Keys.W) && (x==1))
{
Adelante_Click(sender, e);
}
if ((e.KeyCode == Keys.S) && (x == 1))
{
Atras_Click(sender, e);
}
if ((e.KeyCode == Keys.A) && (x == 1))
{
Izquierda_Click(sender, e);
}
if ((e.KeyCode == Keys.D) && (x == 1))
{
Derecha_Click(sender, e);
}
if ((e.KeyCode == Keys.E) && (x == 1))
{
Detener_Click(sender, e);
}

54
if ((e.KeyCode == Keys.J) && (x == 1))
{
Control_Click(sender, e);
}
if ((e.KeyCode == Keys.K) && (x == 1))
{
Automatico_Click(sender, e);
}
if ((e.KeyCode == Keys.L) && (x == 1))
{
Apagar_Click(sender, e);
}
if (e.KeyCode == Keys.Z)
{
}
if (e.KeyCode == Keys.Escape)
{
}
}

55
CODIGO ARDUINO
#include <SoftwareSerial.h>
SoftwareSerial Mod(50,51); // RX | TX
#include <AFMotor.h>
#include <rDHT11.h>
int rDHT11pin = A14;
rDHT11 DHT11(rDHT11pin);
int ilu;
char Var; //Variable que almacena el caracter de bluetooth
int vel=255; //velocidad de motores
int decision=0; //decicion que tomara el carro al dar vuelta al detectar un
obstaculo
int y; //variable para modalidades
int echo=45;
int trig=44;
int duracion;
int distancia;
int lti = 48; //luz trasera izquierda
int ltd = 49; //luz trasera derecha
int ftr; //fotoresistencia
int lad=52; //luz automatica derecha
int lai=53; //luz automatica izquierda
int dd = 35; //direccional derecha
int di = 37; //direccional izquierda
int buzzer1 = 21; //pin positivo buzzer
int buzzer2 = 18; //pin negativo del buzzer

56
long a=0;
long d=0;
long c=0;
long b=100000000000;
long humedad;
void setup(){
pinMode (22,OUTPUT); //Pin negativo del sensor humedad
digitalWrite(22,0);
pinMode (lad,OUTPUT);
pinMode (lai,OUTPUT);
pinMode(lti, OUTPUT);
pinMode(ltd, OUTPUT);
pinMode(di, OUTPUT);
pinMode(dd, OUTPUT);
pinMode(trig, OUTPUT);
pinMode(echo, INPUT);
pinMode(A15, INPUT);
Mod.begin(38400); //Comunicación con el Modulo
Serial.begin(9600); //comunicación con el puerto de serie
Serial.println("Encendido");
}

57
void loop(){
if(Mod.available()>0)//Detectar datos en el modulo
if(Serial.available()>0) //Detectar datos en el serial
Mod.write(Serial.read()); //Ejecutar dato recibidos serial
Var = Mod.read();
a=millis();
luces_automaticas();
if( Var == 'F' ){
y=1;
detener();
Serial.println("FUNCION REMOTA ACTIVADA...");
b=a+5000;
}
if(y==1){
sensores();
control_remoto();
}
if( Var == 'G' ){
Serial.println("APAGADO");
y=0;
detener();
b=0;
c=0;
d=0;
}
if( Var == 'H' ){
Serial.println("FUNCION AUTONOMA ACTIVADA...");
detener();
delay(1000);
y=2;
}
if(y==2){
autonomo();
}

58
if( Var == 'P' ){
Serial.println("ENLAZADO");
y=3;
}
if(y==3){
y=0;
}
}
void control_remoto(){
switch (Var){
case 'W':
avance();
Serial.println("AVANCE");
break;
case 'A':
vuelta_izquierda();
Serial.println("IZQUIERDA");
break;
case 'D':
vuelta_derecha();
Serial.println("DERECHA");
break;
case 'S':
reversa();
Serial.println("REVERSA");
break;
case 'E':
detener();
Serial.println("ALTO");
break;
}
}
void autonomo(){
avance();
decision++;

59
if(decision==3){
decision=1;
}
digitalWrite(trig, HIGH); //genera el pulso de triger por 10ms
duracion = pulseIn(echo, HIGH);
distancia = (duracion/2) / 29; //calcula la distancia en centimetros
if (distancia <= 30 && distancia > 15){
decisiones();
}
if (distancia < 15 && distancia >= 0){
reversa(); delay(500);
decisiones();
}
}
void decisiones(){
if(decision==1){
Serial.println("decision derecha");
vuelta_derecha(); delay(1000);

60
}
if(decision==2){
Serial.println("decision izquierda");
vuelta_izquierda(); delay(1000);
}
}
void avance(){
}
void vuelta_izquierda(){
}
void vuelta_derecha(){

61
}
void reversa(){
}
void detener(){
if((y==1 || y==2)){
}
}
void luces_automaticas(){
ftr=analogRead(A15);

62
if((ftr<300)|| (y==0)){
}
if(((ftr>=300) && (y==1))||((ftr>=500) && (y==2)))
{
}
ilu = map(ftr, 1023, 0, 0, 11);
}
void sensores(){
if (a==b+100)
{
c=a+200;
Mod.write(ilu);
b=0;
}
if (a==c+100)
{
d=a+200;
Mod.write(DHT11.getHumidity());
c=0;

63
}
if (a==d)
{
b=a+200;
Mod.write(DHT11.getCelsius());
d=0;
}

64
BIBLIOGRAFÍAS
https://es.wikipedia.org/wiki/Bluetooth
https://paruro.pe/aprende/arduino/bluetooth/comunicaci%C3%B3n-arduino-pc-
mediante-bluetooth
http://wiki.iteadstudio.com/Serial_Port_Bluetooth_Module_%28Master/Slave%29
_:_HC-05
https://es.wikipedia.org/wiki/Sensor_ultras%C3%B3nico
https://es.wikipedia.org/wiki/Fotorresistor
https://es.wikipedia.org/wiki/Arduino
http://robots-argentina.com.ar/MotorCC_L293D.htm
https://panamahitek.com/el-puente-h-invirtiendo-el-sentido-de-giro-de-un-motor-
con-arduino/
https://www.arduino.cc/en/Main/ArduinoBoardMega2560
http://panamahitek.com/dht11-sensor-de-humedadtemperatura-para-arduino/

Proyecto g.i.d.e.o.n

Más contenido relacionado

Similar a Proyecto g.i.d.e.o.n

Último

Proyecto g.i.d.e.o.n