PFC Jorge De León Rivas
-
Upload
jorge-de-leon-rivas -
Category
Documents
-
view
42 -
download
4
description
Transcript of PFC Jorge De León Rivas
ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA
CIVIL E INDUSTRIAL
Proyecto Fin de Carrera
DESARROLLO DE UN VEHÍCULO ELÉCTRICO DE
CONTROL MANUAL Y REMOTO.
Titulación: Ingeniería Técnica Industrial. Especialidad Electrónica Industrial
Alumno: Jorge De León Rivas
Tutor: D. Jesús Miguel Torres Jorge
28 de Junio de 2013
Agradecimientos
Me gustaría empezar dedicando este proyecto a la memoria de mis abuelos y de mi tío que tanto me enseñaron cuando era pequeño y me atrajeron a este mundo de la electrónica.
Quiero expresar mi agradecimiento, por su insustituible ayuda en este proyecto, a mi tutor, Jesús Torres.
Y expresar también mi gratitud al resto de personas que me han ayudado a lograr mi objetivo. Algunas me han ayudado aportando material, otras una mano, o las dos, cuando ha hecho falta montarlo algo y otras me han dado los empujones anímicos cuando más me han hecho falta.
Sin el apoyo de todos ellos, no lo hubiese conseguido.
Muchas gracias a todos.
“[…] En un mundo donde hay más ordenadores que personas, tenemos que comprender como funcionan las cosas, ya no para poder arreglarlos, sino, sencillamente, para poder comprender como funciona nuestra vida.
Y yo creo que es una necesidad.”.
David Cuartiles. Arduino: The Documentary. 2010.
Parte I
Memoria
ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA
CIVIL E INDUSTRIAL
Proyecto Fin de Carrera
DESARROLLO DE UN VEHÍCULO ELÉCTRICO DE
CONTROL MANUAL Y REMOTO.
TOMO I
Memoria
Titulación: Ingeniería Técnica Industrial. Especialidad Electrónica Industrial
Alumno: Jorge De León Rivas
Tutor: D. Jesús Miguel Torres Jorge
28 de Junio de 2013
Índice
1. INTRODUCCIÓN: ............................................................................................ 1 1.1 Marco general del proyecto: ........................................................................................................................ 1 1.2 Objetivos: ......................................................................................................................................................... 3
1.2.1 Etapas del proyecto .......................................................................................................................................... 4 1.3 Estructura de la memoria: ............................................................................................................................ 6
2. MARCO Y ASPECTOS GENERALES: ............................................................. 7 2.1 Descripción general del proyecto: .............................................................................................................. 7 2.2 Software y hardware abierto: ....................................................................................................................... 8
2.2.1 Arduino: .......................................................................................................................................................... 9 2.2.2 ISIS Proteus: ................................................................................................................................................ 15 2.2.3 DIPTrace: .................................................................................................................................................... 16 2.2.4 LiveCode Community 6.0: .......................................................................................................................... 16
3. ANÁLISIS DE OTROS VEHÍCULOS CONSTRUIDOS, DISEÑO Y FABRICACIÓN DEL PROTOTIPO: .................................................................... 17 3.1 Go-karts: ......................................................................................................................................................... 17 3.2 Vehículos estudiados: .................................................................................................................................. 18
3.2.1 CapKart: ....................................................................................................................................................... 18 3.2.2 TinyKart: ...................................................................................................................................................... 21 3.2.3 Alexei 6x6: .................................................................................................................................................. 21 3.2.4 NeurotiKart: ................................................................................................................................................. 22
3.3 Diseño y construcción: ............................................................................................................................... 23
4. DISEÑO DE LA ELÉCTRONICA DEL VEHÍCULO ................................... 33 4.1 Idea general: ................................................................................................................................................... 33 4.2 Arduino MEGA 2560: ................................................................................................................................ 35 4.3 Módulo Ethernet: ......................................................................................................................................... 38 4.4 Panel de control: ........................................................................................................................................... 39
4.4.1 Interruptor selector de modo: ........................................................................................................................ 40 4.4.2 Interruptor selector marcha: ......................................................................................................................... 48 4.4.3 Acelerador de moto: ...................................................................................................................................... 51 4.4.4 Thumb joystick: ............................................................................................................................................ 52 4.4.5 Displays 7 segmentos: ................................................................................................................................... 55 4.4.6 Panel LED informativo: ............................................................................................................................. 58 4.4.7 PCB Panel de Control: ................................................................................................................................ 60
4.5 Sistema de dirección: ................................................................................................................................... 60 4.6 Sistema de tracción: ..................................................................................................................................... 66
4.6.1 Puente H: ..................................................................................................................................................... 69 4.7 Protecciones: .................................................................................................................................................. 87 4.8 Conexiones eléctricas y secciones de cable: ........................................................................................... 89
5. DISEÑO DEL SOFTWARE PARA ARDUINO .............................................. 92 5.1 Esquema general: ............................................................................................................................................. 92 5.2 Local 1: ............................................................................................................................................................ 93 5.3 Local 2: ............................................................................................................................................................ 93 5.4 Remoto: ............................................................................................................................................................. 95 5.5 Avance: ............................................................................................................................................................. 96 5.6 Retroceso: .......................................................................................................................................................... 96 5.7 Paro: ................................................................................................................................................................. 97
MEMORIA 14
5.8 Letrero: ............................................................................................................................................................. 97
6. DISEÑO DEL SOFTWARE PARA EL DISPOSITIVO MÓVIL .................... 99 6.1 Introducción ...................................................................................................................................................... 99 6.2 Comunicación ................................................................................................................................................. 100 6.3 Estructura del programa ............................................................................................................................... 101 6.3.1 Carta Inicio: ............................................................................................................................................... 101 6.3.2 Carta Configuración: ................................................................................................................................. 102 6.3.3 Carta Conducción: ..................................................................................................................................... 103
7. CONCLUSIONES Y RESULTADO: ............................................................ 106
8. BIBLIOGRAFÍA: ........................................................................................... 108
MEMORIA 15
Índice de ilustraciones
Ilustración 1.1 Dispositivo de control de velocidad "chino" ..................................... 2
Ilustración 1.2 Diagrama de flujos de las etapas del proyecto. ................................... 4
Ilustración 1.3 Procedimiento de desarrollo del vehículo ........................................... 6
Ilustración 2.1 Elementos de control del vehículo ...................................................... 8
Ilustración 2.2 Miembros del Arduino Team ............................................................ 10
Ilustración 2.3 Comparación entre la placa Arduino y la BASIC Stamp .................. 10
Ilustración 2.4 Comparativa de precios entre el chip ATMega y el BASIC ............... 11
Ilustración 2.5 Primera placa de wiring ...................................................................... 11
Ilustración 2.6 Primer prototipo de placa Arduino ................................................... 12
Ilustración 2.7 IDE. Entorno de desarrollo de Arduino ............................................ 13
Ilustración 2.8 Primera placa de Arduino oficial ....................................................... 14
Ilustración 2.9 Diferentes modelos de placas de Arduino ......................................... 15
Ilustración 2.10 Arduino + módulo Ethernet ............................................................ 15
Ilustración 3.1 Modelos de Go-Karts de madera ....................................................... 17
Ilustración 3.2 Modelos de Go-Karts más elaborados ............................................... 18
Ilustración 3.3 CapKart .............................................................................................. 19
Ilustración 3.4 Diferencial del CapKart ..................................................................... 19
Ilustración 3.5 Batería del CapKart ........................................................................... 19
Ilustración 3.6 Motor del CapKart y esquema de protección .................................... 20
Ilustración 3.7 Caja del ultra-condensador ................................................................ 20
Ilustración 3.8 Detalles del TinyKart ......................................................................... 21
Ilustración 3.9 Detalles del Alexei 6x6 ....................................................................... 22
Ilustración 3.10 NeurotiKart ...................................................................................... 23
Ilustración 3.11 Componentes principales de un kart ............................................... 24
Ilustración 3.12 Planos de un chasis casero .............................................................. 25
Ilustración 3.13 Distintas fotos del miniquad ............................................................ 26
Ilustración 3.14 Detalles del miniquad ...................................................................... 27
Ilustración 3.15 Organización del kart ...................................................................... 27
Ilustración 3.16 Detalle del soporte para motor ........................................................ 28
Ilustración 3.17 Manillar y brazo de la dirección ...................................................... 29
Ilustración 3.18 Tornillos del vehículo ...................................................................... 30
Ilustración 3.19 Detalle del eje trasero ....................................................................... 31
Ilustración 3.20 Diseño del barstool .......................................................................... 32
Ilustración 4.1 Entradas y salidas necesarias ............................................................ 34
MEMORIA 16
Ilustración 4.2 Estructura del programa ................................................................... 37
Ilustración 4.3 Arduino Mega .................................................................................... 38
Ilustración 4.4 Ethernet shield .................................................................................. 38
Ilustración 4.5 Elementos del panel de control ......................................................... 39
Ilustración 4.6 Selector de modo ............................................................................... 40
Ilustración 4.7 Voltajes para el selector de modo ...................................................... 41
Ilustración 4.8 Divisor de tensión .............................................................................. 41
Ilustración 4.9 Conexiones del selector de modo ...................................................... 42
Ilustración 4.10 Conexiones del selector de modo en la protoboard ........................ 45
Ilustración 4.11 Selector de marcha ........................................................................... 48
Ilustración 4.12 Conexiones selector de marcha ....................................................... 49
Ilustración 4.13 Conexiones del selector de marcha en la protoboard ...................... 50
Ilustración 4.14 Acelerador de moto .......................................................................... 51
Ilustración 4.15 Conexiones acelerador de moto ....................................................... 51
Ilustración 4.16 Thumb joystick ................................................................................ 52
Ilustración 4.17 Ejes del thumb joystick .................................................................... 52
Ilustración 4.18 Conexiones thumb joystick e interruptores fin de carrera .............. 53
Ilustración 4.19 Conexiones thumb joystick en la protoboard .................................. 53
Ilustración 4.20 Valores de los potenciometros para las acciones ............................ 54
Ilustración 4.21 Displays de 7 segmentos .................................................................. 55
Ilustración 4.22 Conexiones de los displays .............................................................. 56
Ilustración 4.23 Conexión display cátodo común ..................................................... 58
Ilustración 4.24 LED SMD ........................................................................................ 58
I Ilustración 4.25 Posición LEDs indicadores .......................................................... 59
Ilustración 4.26 Diseño PCB para el panel de control .............................................. 60
Ilustración 4.27 Sistema de dirección hidraúlico ...................................................... 61
Ilustración 4.28 Funcionamiento de un servomotor ................................................. 62
Ilustración 4.29 Actuador eléctrico para la dirección ................................................ 63
Ilustración 4.30 Puente H con LM298 y datos técnicos ............................................ 63
Ilustración 4.31 Rectas de carga del actuador eléctrico ............................................ 64
Ilustración 4.32 Sistema de dirección del vehículo ................................................... 65
Ilustración 4.33 Resistencia pull-down del interruptor fin de carrera ....................... 66
Ilustración 4.34 Primer motor utilizado .................................................................... 68
Ilustración 4.35 Comparación entre el primer motor y el segundo ........................... 68
Ilustración 4.36 Desgaste en el neumático para la colocación del motor ................. 69
MEMORIA 17
Ilustración 4.37 La letra H formada por la ubicación de los conmutadores en el circuito ....................................................................................................................... 70
Ilustración 4.38 Circulación de la corriente según las llaves que se cierren ............. 70
Ilustración 4.39 Primer puente H creado .................................................................. 71
Ilustración 4.40 Datos necesarios para el funcionamiento de los MOSFETs .......... 71
Ilustración 4.41 Etapa BJT ........................................................................................ 73
Ilustración 4.42 Respuesta de la etapa BJT ............................................................... 74
Ilustración 4.43 Etapa BJT con motor y respuesta de la etapa ................................. 74
Ilustración 4.44 Etapa radiofrecuencia y resultado ................................................... 75
Ilustración 4.45 Etapa radio frecuencia y resultados ................................................ 75
Ilustración 4.46 Configuración PWM Arduino .......................................................... 76
Ilustración 4.47 Resultado etapa 7.8125 kHz ............................................................. 76
Ilustración 4.48 Etapa optoacoplador y resultado ..................................................... 77
Ilustración 4.49 Distintas pruebas para la activación del N-MOS ............................ 78
Ilustración 4.50 Puente H de Gary L. Chemelee ....................................................... 79
Ilustración 4.51 Gráficas para la optimización del optoacoplador ............................ 80
Ilustración 4.52 Esquema conexión optoacoplador .................................................. 81
Ilustración 4.53 Resultados Puente H definitivo ....................................................... 82
Ilustración 4.54 Placa para los optoacopladores ....................................................... 83
Ilustración 4.55 Diodo en paralelo con inductancia .................................................. 84
Ilustración 4.56 Diodo en paralelo con resistencia en serie ...................................... 85
Ilustración 4.57 Diodo empleado en el proyecto ....................................................... 85
Ilustración 4.58 Colocación de los diodos de protección .......................................... 86
Ilustración 4.59 Interruptor magnetotérmico ............................................................ 87
Ilustración 4.60 Fusible de car audio empleado ........................................................ 88
Ilustración 4.61 Conexiones del vehículo .................................................................. 89
Ilustración 4.62 Caja de control ................................................................................. 91
Ilustración 4.63 Conexiones de los MOSFETs y el mototr ....................................... 91
Ilustración 5.1 Esquema general ............................................................................... 92
Ilustración 5.2 Modo "Local 1" ................................................................................. 93
Ilustración 5.3 Modo "Local 2" ................................................................................. 94
Ilustración 5.4 Modo "Volante" ................................................................................ 94
Ilustración 5.5 Modo "Remoto" ................................................................................ 95
Ilustración 5.6 Función "Avance" ............................................................................. 96
Ilustración 5.7 Función "Retroceso" ........................................................................ 96
Ilustración 5.8 Función "Paro" ................................................................................. 97
MEMORIA 18
Ilustración 5.9 Función "Letrero" ............................................................................. 98
Ilustración 6.1 Conexión vía wifi ............................................................................. 100
Ilustración 6.2 Estructura del programa .................................................................. 101
Ilustración 6.3 Carta "Inicio" ................................................................................... 101
Ilustración 6.4 Carta "Configuración" .................................................................... 102
Ilustración 6.5 Carta "Conducción" ........................................................................ 103
Ilustración 6.6 Carta "Conducción" ........................................................................ 103
Ilustración 6.7 Acelerómetros del móvil .................................................................. 104
Ilustración 6.8 Modo "Avance" activado ................................................................ 105
MEMORIA 19
Índice de tablas
Tabla 2.1 Modos de funcionamiento del vehículo ..................................................... 8
Tabla 3.1 Comparativa vehículos ya construidos ...................................................... 23
Tabla 4.1 Entradas y salidas necesarias .................................................................... 35
Tabla 4.2 Conexiones Serial del Arduino .................................................................. 37
Tabla 4.3 Pines para interrupciones externas del Arduino ....................................... 37
Tabla 4.4 Pines seleccionados ................................................................................... 40
Tabla 4.5 Conexiones selector de marcha ................................................................. 48
Tabla 4.6 Valores para un display .............................................................................. 57
Tabla 4.7 Valores resistencias para los LEDs ........................................................... 60
Tabla 4.8 Datos técnicos del motor ........................................................................... 66
Tabla 4.9 Secciones de cable calculadas ................................................................... 90
MEMORIA 1
1. INTRODUCCIÓN:
Es bastante difícil imaginar el mundo actual sin los medios de transporte que nos
rodean y utilizamos a diario. Sin ellos seguiríamos desplazándonos a pie o sobre animales y,
por supuesto, nos sería imposible recorrer las largas distancias en el tiempo que empleamos
diariamente.
En las ciudades más masificadas del mundo, el coche es el medio de transporte más
usado pero debido a la gran cantidad de contaminación que generan y el movimiento
social, que cada vez está adquiriendo más importancia, de concienciación social sobre el
cuidado del medio ambiente la gente, al igual que los fabricantes de vehículos, se han dado
cuenta de que es hora de empezar a cambiar para poder vivir en un ambiente menos
nocivo.
Es por ello, que desde la década anterior, y junto con la alerta de las existencias de
petróleo han tomado más importancia en la sociedad actual los vehículos de energías
alternativas. De entre todas las alternativas los vehículos que más auge tienen son los
híbridos y eléctricos.
1.1 Marco general del proyecto:
Este proyecto de fin de carrera ha fijado su objetivo en la realización de un
prototipo de vehículo eléctrico capaz de desplazar a una persona por una ciudad sin
generar ningún tipo de contaminación ayudando a mejorar la calidad de vida.
Durante los últimos años con la gran reducción en los precios de los componentes
electrónicos, la gran evolución que han tenido los microcontroladores y la espectacular
evolución de información en internet son incontables los proyectos que se pueden
encontrar de vehículos eléctricos caseros que se han creado.
Los circuitos que gobiernan estos vehículos también han evolucionado en gran
medida, en un principio solo eran posibles para gente que poseyese elevados
conocimientos de electrónica y pudiese elaborar sus propias placas, pero a día de hoy con el
auge de la industria china se pueden encontrar los circuitos ya montados de forma que solo
hace falta instalarlo en el vehículo y conectarle las entradas y salidas tal y como se muestra
en la figura 1.1.
MEMORIA 2
Sin embargo estos módulos que se pueden adquirir tienen sus limitaciones y solo
ofrecen un sentido de giro a las ruedas. Y para un coche esto es insuficiente, un coche debe
poder moverse tanto hacia delante como marcha atrás o quedarse quieto. También necesita
de una dirección que por norma general suele ser manual, pero lo ideal es crear una que
funcione de manera electrónica para gente con discapacidad que se vea incapaz de mover
un volante.
La idea que ayudó a impulsar este proyecto como proyecto de fin de carrera surge a
raíz de un artículo publicado en el blog de bricogeek.
“Con su estupendo y elegante acabado el Chibikart hace que sus desarrolladores se
sientan como niños en el MIT. Es una variación (evolución?) del tinyKart y utiliza dos potentes
motores eléctricos bobinados y hechos a medida que van incrustados dentro de una pequeña rueda.
El resultado es absolutamente impresionante. Está claro que en un proyecto así no vale la pena
hacerse uno solo sino dos para darse una pachanga! No os perdáis la mini carrera nocturna en un
aparcamiento del MIT con estos dos bichos... no tiene precio.
Bueno vale, me pido uno, o mejor dos, para navidades (para ir adelantando tiempo) !”
En él se muestra la evolución del primer diseño que había hecho el MIT
(Massachusetts Institute of Technology) de un go-kart.
La mayoría de los vehículos caseros creados suelen emplearse para el disfrute
personal y suelen fabricarse una única vez. Con este proyecto se pretende sentar las bases
para crear un movimiento que ayude a la gente a fabricar sus propios vehículos.
Los requisitos que se han de conseguir es que sea un vehículo eléctrico de pequeño
tamaño fácil de manejarse, sobre todo para personas con discapacidad, que tenga
Ilustración 1.1 Dispositivo de control de velocidad "chino"
MEMORIA 3
autonomía suficiente para un uso diario y, por supuesto, sea de bajo costo y siempre en la
mente la idea del open-hardware.
En este proyecto se prototipará un vehículo con las ideas mencionadas
anteriormente.
1.2 Objetivos:
El objetivo principal de este proyecto es crear un diseño de vehículo con los
componentes eléctricos y electrónicos necesarios para su funcionamiento autónomo y dar
toda la información necesaria para que la gente que lo desee pueda producir el suyo propio.
La mayor de las expectativas del proyecto es que el prototipo sea capaz de cumplir los
objetivos del diseño y su funcionamiento sea aceptable. Se realizan los trabajos y objetivos
del proyecto siguiendo una secuencia lógica para el procedimiento. Dicha secuencia se
puede observar en el esquema 1.1.
MEMORIA 4
1.2.1 Etapas del proyecto
Por orden cronológico, las etapas del proyecto fueron la documentación y estudio
de vehículos ya construidos, el estudio de los circuitos eléctricos y de los componentes
necesarios, el estudio y diseño del vehículo, el estudio de la tarjeta Arduino, análisis de las
comunicaciones de red local y servidor-cliente, desarrollo de software y hardware para
cumplir los requisitos y sus pruebas de funcionamiento y finalmente la implementación del
vehículo.
Documentac ión y es tudio de vehículos ya construidos :
Se adquiere y revisa diversa información de algunos de los vehículos creados por
diferentes personas u organizaciones y se analizan sus puntos fuertes y los débiles para
tenerlos en cuenta en el diseño final.
Documentación
Diseño software para Android
Diseño software para Ardunio
Diseño hardware
Construcción chasis
Estudio elementos necesarios
Ilustración 1.2 Diagrama de flujos de las etapas del proyecto.
MEMORIA 5
Estudio de los c i r cui tos e l é c tr i cos y de los componentes necesar ios :
Se dedicó bastante tiempo a la labor de estudiar, encontrar y adaptar los circuitos
eléctricos para el control del motor, de la dirección, un panel de información, los
actuadores necesarios, los sensores, tarjeta controladora Arduino y módulo de Ethernet.
Diseño y construcc ión de la es tructura de l vehículo :
Con la información recabada en los dos apartados anteriores se buscó el mejor
diseño del vehículo para proceder a su construcción.
Estudio de la tar j e ta Arduino:
Se estudió toda la información referente al microcontrolador, una placa Arduino y
el módulo Ethernet.
Anális i s de las comunicac iones de red local y serv idor -c l i ente :
Se analizaron como es la estructura de las redes locales y sus configuraciones, así
como se comporta una estructura servidor-cliente.
Desarrol lo de so f tware :
Se realizaron los códigos y programas necesarios para ejecutar el control del
vehículo y el enlace. Para ello hubo que programar el cliente en una aplicación para el
sistema operativo Android y el servidor junto con el control del vehículo en la placa
Arduino.
Desarrol lo de hardware :
Se desarrolló el hardware necesario. Se diseñaron y fabricaron las siguientes placas:
una placa controladora para el puente H, otra para la selección de modos, marcha y luces,
otra para los LEDs indicadores de estado del coche, y otra para indicar la posición del
acelerador.
Requis i tos de l diseño:
El vehículo a implementar debía de cumplir una serie de criterios y especificaciones
para su correcto funcionamiento y su uso a posterior. Entre estos criterios se encuentran su
funcionalidad y su bajo coste. Además los dispositivo a fabricar deberá ser capaz de tener
una autonomía suficiente para su uso diario y capaz de soportar climatología adversa, por
lo que deberán estar protegidos contra los efectos del viento, la lluvia, el sol, la humedad y
MEMORIA 6
posibles agresiones físicas. La autonomía resulta un factor muy importante, y se debe
pensar que el dispositivo ha de poder funcionar el suficiente tiempo como para no
quedarse sin energía a mitad del recorrido.
Pruebas:
En esta etapa se comprueba el funcionamiento del prototipo desarrollado y se
observan sus capacidades. Se realizan medidas de alcance con el cliente-servidor, pruebas
de duración de las baterías y de manejabilidad. Con todas estas pruebas realizadas se
estudian posibilidades para mejorar el vehículo.
1.3 Estructura de la memoria:
Para la elaboración de este documento se ha utilizado el programa Microsoft Office
como sistema de preparación de documentos para la impresión de alta calidad. Se ha
estructurado en tres partes: la primera contiene la memoria. El pliego de condiciones y el
presupuesto se encuentran en la segunda y en la última parte se han incluido algunos
anexos con los listados de programas, los esquemas electrónicos realizados y algunas hojas
de datos de especial interés. La primera parte que contiene la memoria del proyecto se ha
comenzado con esta introducción, se sigue con la descripción del marco del proyecto y una
introducción general de las partes del mismo. Seguidamente se describen en 4 capítulos
separados, análisis de otros vehículos construidos, diseño y fabricación del prototipo,
desarrollo y prueba de toda la electrónica del control, estructura del código implementado
en Arduino y estructura del programa creado para los dispositivos móviles.. El siguiente
capítulo contiene los resultados obtenidos tanto de las distintas pruebas realizadas como
frente a los objetivos planteados.
Ilustración 1.3 Procedimiento de desarrollo del vehículo
NO
DOCUMENTACIÓN ESTUDIO
COMPONENTES NECESARIOS
DISEÑO VEHÍCULO DISEÑO SOFTWARE DISEÑO HARDWARE ¿FUNCIONA CORRECTA-‐MENTE?
FIN
MEMORIA 7
2. MARCO Y ASPECTOS GENERALES:
En este capítulo se realiza una descripción general del proyecto, así como de los
aspectos más genéricos del proyecto, tratándose temas como el uso del software y
hardware abierto.
2.1 Descripción general del proyecto:
Se trata de un vehículo capaz de funcionar de manera autónoma, cuya conducción
pueda realizarse sentado en el mismo o con una comunicación mediante el estándar 802.11,
Wi-fi, con un dispositivo que utilice el sistema operativo Android y actúe como cliente.
En la figura 2.1 se muestra esquemáticamente las partes del sistema. En la parte de
electrónica es donde se ha realizado la mayor parte del desarrollo del proyecto. Consta de
una etapa con optoacopladores para aislar el Arduino del circuito de potencia, un puente H
para controlar los dos sentidos de avance, otro puente H para el actuador lineal de la
dirección y la tarjeta de Arduino con el módulo Ethernet. La conexión entre los puente H y
el procesador se hace a través de los pines de entrada y salida de éste último. El Arduino y
el módulo Ethernet se encargan del envío y la recepción en paquetes TCP/IP por Ethernet
a través del router instalado. Por medio de la antena del router se genera una señal Wi-fi
con la que se enlaza al dispositivo cliente.
A grandes rasgos, tenemos un proyecto en el que se usarán tanto salidas del tipo
booleano como PWM, entradas analógicas y conexiones mediante red local. Donde hará
falta implementar circuitos de electrónica digital y de potencia, configurar la velocidad de
trabajo del Arduino para que el motor funcione correctamente y crear una red servidor-
cliente.
A continuación se muestra un esquema del sistema de control del coche y como
circula el envío de información. Además se incluye una tabla con los modos de
funcionamiento.
MEMORIA 8
Modo Tracción Dirección
Local 1 Acelerador de moto Manual
Local 2 Eje Y Thumbpad Eje X thumbpad
Remoto Teléfono móvil Teléfono móvil
Tabla 2.1 Modos de funcionamiento del vehículo
2.2 Software y hardware abierto:
Se han realizado todos o casi todos los objetivos de este proyecto utilizando
software y hardware libre o en versiones gratuitas. Lo que ha resultado eficaz, versátil y
funcional. El software libre o abierto es todo aquel que cumpla con las cuatro libertades,
“libertad de usar el programa para cualquier propósito”, “libertad para poder estudiar,
modificar el programa y adaptarlo a nuestras necesidades”, “libertad de distribuir
libremente copias del software” y “libertad para mejorar el código y hacer públicas dichas
mejoras con la finalidad de que la comunidad de usuarios se beneficie”.
Ilustración 2.1 Elementos de control del vehículo
MEMORIA 9
De un mismo modo es aplicable la cualidad de libre a todo aquel hardware cuyas
especificaciones, esquemas e información referente a su fabricación y uso sean de carácter
público.
“La idea del open-hardware nace debido, a que por culpa de la estandarización y del
sistema de patentes, se cierra la posibilidad para mucha gente la oportunidad de aprender
como funcionan las cosas y queda reservado a un grupo de gente, que son los hackers, que
por tener mayores conocimientos técnicos, o se sentían con la capacidad de abrir un
elemento electrónico y mirar que es lo que había dentro. Y, es que el hardware-abierto
significa volver a mirar que hay dentro de las cosas, pero hacerlo de una forma que esté
permitido, o sea, que sea éticamente correcto, que sea legal, y que permita mejorar la
educación. Entonces el hardware-abierto es un sistema que permite a la gente educarse en
como funcionan las cosas. En un mundo donde hay más ordenadores que personas,
tenemos que comprender como funcionan las cosas, ya no para poder arreglarlos, sino,
sencillamente, para poder comprender como funciona nuestra vida. Y yo creo que es una
necesidad.”. David Cuartiles. Arduino: The Documentary. 2010.
En este proyecto se decide realizar todos los trabajos, que sean posibles, con
herramientas tanto de software como de hardware libre. Los elementos usados se describen
brevemente en las siguientes subsecciones.
2.2.1 Arduino:
Arduino comenzó como un proyecto en el Instituto de Diseño Interactivo de Ivrea
(IDII o Ivrea), Italia, en 2005. Pero su origen está ya estaba presente en otros proyectos en
los que habían trabajo sus creadores.
El equipo de desarrollo de Arduino está formado por: Massimo Banzi (diseñador y
creador web), David Cuartielles (ingeniero electrónico), Tom Igoe (profesor at New York
University's Interactive Telecommunications Program (ITP)), Gianluca Martino (diseñador
y fabricante de las placas) y David Mellis (ingeniero en el MIT).
MEMORIA 10
El objetivo era crear una herramienta para los estudiantes que fuera más moderna
de las que había disponible en el mercado, sobre todo, porque la herramienta que usaba
todo el mundo, se llamaba BASIC Stamp.
Una placa de BASIC Stamp costaba unos 80€ (alrededor de 119$) así que resultaba
muy caro para los estudiantes que no querían gastar dinero en comprar muchas placas tan
Ilustración 2.2 Miembros del Arduino Team
Ilustración 2.3 Comparación entre la placa Arduino y la BASIC Stamp
MEMORIA 11
caras, por lo que empezaron a buscar alternativas, además estaban trabajando en
processing. Así que decidieron hacer un simil de este lenguaje de programación en
hardware.
Con esta idea nació la plataforma wiring y a partir de su finalización, el team
Arduino empezó a buscar como hacerla más simple, barata y sencilla de usar. El
proyecto Arduino nació con filosofía open source, pero ésta idea se hizo más imperativa
con el rumor de que Ivrea pudiese cerrar por falta de fondos. Fue por ello que sus
creadores apostaron, sí o sí, por hacer una plataforma open-hardware; con el objetivo de
que sus progresos no quedaran olvidados en una caja y se crease una gran comunidad de
desarrollo y conocimiento, tal y como se conoce a la plataforma hoy en día.
Cuando Massimo Banzi y David Cuartielles comenzaron a colaborar, ya con la idea
del open-hardware, pasaron de discutir sobre lo que tenían que hacer a como debían
hacerlo. Massimo Banzi había realizado una serie de proyectos con una determinada
Ilustración 2.5 Primera placa de wiring
Ilustración 2.4 Comparativa de precios entre el chip ATMega y el BASIC
MEMORIA 12
tecnología y David Cuartielles con otra diferente, debatieron sobre cual era la mejor y
decidieron probar la tecnología de Massimo Banzi debido a su mejor compatibilidad con
diferentes sistemas operativos.
A continuación, David Cuartielles revisó el hardware, en el que encontró un par de
bugs, los arreglaron y empezó el diseño de fabricación de placas.
El proceso de diseño de la placa duró únicamente dos días y el resto del tiempo se
dedicó al software.
En la nueva etapa del proyecto se unió al equipo (formado hasta ahora solo por
Massimo Banzi y David Cuartielles) David Mellis, posteriormente entró Tom Igoe como
consejero y por último llegó Gianluca Martino, que era quien podía producir las placas.
Así fue como se formó el equipo, añadiendo gente según sus habilidades.
Cuando David Mellis entró en el proyecto, todavía seguían usando las placas wiring
creadas por Hernando Barragán y su objetivo era poder portar los programas que se
creaban a un procesador más barato.
David Mellis se encargó de escribir un montón de capas de compatibilidad para que
todos los programas antiguos funcionasen en el procesador nuevo.
Ilustración 2.6 Primer prototipo de placa Arduino
MEMORIA 13
El resultado de todas las horas de programación y compilación fue el IDE o
Integrated Development Environment.
Tom Igoe se enteró, a principios del 2005, que se estaba desarrollando una
alternativa en hardware al processing. En junio de 2005, coincidió que fue a Ivrea a dar una
charla sobre otro tema y aprovechó para que le enseñasen el desarrollo hasta la fecha de la
placa de Arduino. En cuanto la vio apostó por ella y se lo hizo saber al equipo de
desarrollo.
Unos meses después de volver a Estados Unidos, recibió un correo desde Ivrea en
el que le decían que querían lanzar Arduino de forma global y le pedían su ayuda. De esta
forma fue como entró como consejero.
Tras el primer prototipo de Arduino, el equipo tenía la necesidad, o al menos la
intención, de empezar a fabricar algo de forma más profesional, más comercial, porque el
primer ejemplo se montó solo para que pudiese continuar su desarrollo. Cuando Massimo
Banzi y David Cuartielles decidieron que el prototipo funcionaba, era necesario crear un
lote mayor para su producción.
Ilustración 2.7 IDE. Entorno de desarrollo de Arduino
MEMORIA 14
Así que decidieron crear un lote de 200 unidades y Gianluca Martino realizó una
serie de modificaciones para poder realizar su producción en serie.
Como era una primera prueba, llegaron a un acuerdo con la escuela, el Instituto de
Diseño Interactivo y el K3 de Maluno, para comprar 50 unidades cada uno. Fue un buen
principio.
Tras anunciarse un poco y hablar con conocidos el movimiento se puso en marcha.
En 2010 se estimaban unas ventas de tarjetas oficiales de Arduino de 250.000, sin contar
sus clones chinas. A día de hoy el número de placas oficiales ha crecido de forma
exponencial.
Actualmente Arduino tiene 17 placas oficiales y siguen en constante evolución y
desarrollo, mejorando los diseños e integrando mejores procesadores.
Ilustración 2.8 Primera placa de Arduino oficial
MEMORIA 15
A parte de las placas oficiales también salen extensiones (shields) para conectar
sensores, actuadores, módems, …
2.2.2 ISIS Proteus:
ISIS Proteus es un programa de diseño y simulación incluido en el paquete de
desarrollo de Proteus. En este paquete también se incluyen otros módulos como: ARES
Ilustración 2.9 Diferentes modelos de placas de Arduino
Ilustración 2.10 Arduino + módulo Ethernet
MEMORIA 16
(Diseño de PCB), VSM (Simulador Virtual de Modelado) y Electra (Autoruteado). Aunque
para este proyecto solo se utilizará ISIS.
ISIS Proteus es una de las aplicaciones de simulación de circuitos más potentes que
se pueden encontrar en el mercado a nivel de usuario. Su mayor punto fuerte es la
capacidad de poder correr programas creados para microprocesadores y la veracidad de sus
simulaciones.
En un principio para este proyecto se utilizaron alternativas gratuitas o con versión
de estudiante como fueron LTspice IV y CADENCE PSpice. Estos dos programas
también son dos referentes en el campo de la simulación pero al contrario del ISIS los
resultados que mostraban no eran fieles a la realidad, lo que provocó en el proyecto un
retraso de un mes hasta que se cambió el programa de simulación.
Según los datos obtenidos, LTspice y ORCAD decían que los MOSFET podrían
trabajar perfectamente hasta 40kHz y las etapas con BJT también, sin embargo la
implementación física y Proteus mostraron que no eran ciertos esos datos.
2.2.3 DIPTrace:
DipTrace es un software DEA(Diseño Electrónico Asistido, EDA Electronic
Design Assit) creado para realizar diagramas de conexiones y placas impresas (PCB Printed
Circuit Board). La primera versión se lanzó en agosto de 2004. La última versión, 2.3, es de
octubre de 2012. DipTrace cuenta con los siguientes módulos para sus distintas funciones:
editor de esquemáticos, editor de PCB, editor de componentes, editor de pattern
(footprints), autoruteo de pistas, vista previa de PCB en 3D.
Las versiones gratuitas de DipTrace son completamente funcionales excepto
porque tienen un límite de 300 pines y dos capas (a parte de la alimentación y tierra) por
PCB.
2.2.4 LiveCode Community 6.0:
LiveCode Community es una aplicación open source y utiliza como lenguaje de
programación LiveCode inspirado en HyperTalk.
El lenguaje fue lanzado en 2001 y está basado en la tecnología MetaCard. LiveCode
es multiplataforma (iOS, Android, Mac OS X, Windows y Linux).
MEMORIA 17
3. ANÁLISIS DE OTROS VEHÍCULOS CONSTRUIDOS, DISEÑO Y
FABRICACIÓN DEL PROTOTIPO:
Como en todo proceso de diseño es necesario buscar referencias para encontrar
soluciones adecuadas al problema. Además de que se puede hacer un proceso más eficaz
observando los problemas que han surgido en los otros proyectos.
La idea en la que centró el diseño y la búsqueda de prototipos fueron los go-karts.
3.1 Go-karts:
Un go-kart es un tipo de vehículo pequeño y sin suspensión. Éstos se pueden
encontrar con diferentes diseños (de madera, metal, tuberías,...) y motores.
La gente suele asociar los go-karts con niños pequeños, pero ni mucho menos, gente
de todas las edades compite con go-karts y, a menudo, los utilizan como base para,
posteriormente, subir a categorías más avanzadas del deporte del motor.
Las carreras de go-karts son populares en Norte América y Europa, tanto es así, que
sus numerosas competiciones son reguladas por la FIA (Federación Internacional de
Automovilismo, la misma que rige la F1).
Los más simples suelen denominarse billy kart o soap-box kart y no son más que una
simple caja, o armazón, con ruedas y dirección. Éstos vehículos no suelen tener motores y
están destinados a las carreras que se realizan tirándose desde lo alto de una colina.
Ilustración 3.1 Modelos de Go-Karts de madera
MEMORIA 18
Los go-karts motorizados se pueden encontrar con diferentes tipos de motores: de
combustión de 4 tiempos, de combustión de 2 tiempos, que utilicen alcohol o gas propano
como combustible o eléctricos.
Estos vehículos son lo suficientemente adaptables para ser utilizados en distintos tipos
de superficie. En Estados Unidos suelen usarse sobre todo para caminos de tierra con ruedas
de tacos, en el norte de Europa con ruedas de clavos para las pistas de hielo, y como no,
siempre se podrán usar sobre asfalto.
3.2 Vehículos estudiados:
A continuación se muestran varios de los vehículos construidos que se estudiaron para
observar sus puntos fuertes y débiles.
3.2.1 CapKart:
El Cap Kart fue el segundo vehículo creado en el Campus de Verano de
Ingeniería del Centro Edgerton, en verano de 2008. En un go-kart eléctrico con una
batería y un ultra-condensador basado en el almacenamiento de la energía. La batería
aporta la alimentación de forma constante, mientras que el ultra-condensador se usa a
modo de turbo, inyectando un extra de potencia.
Ilustración 3.2 Modelos de Go-Karts más elaborados
MEMORIA 19
El proyecto empezó a partir de un chasis de kart. Éste es grande, fuerte y
relativamente ligero. Posteriormente, para mejorar el control del coche en los giros
lentos, se le añadió en 2010 un diferencial al eje trasero.
Ilustración 3.5 Batería del CapKart
Ilustración 3.3 CapKart
Ilustración 3.4 Diferencial del CapKart
MEMORIA 20
La fuente de energía principal del kart es un pack de baterías de litio-ion de
12V Thundersky. El peso de la batería era de 20 kg, mientras que una de ácido-plomo
pesaba 72 kg.
El nombre que tiene el coche proviene del ultra-condensador de 110F y 16V
que actúa como turbo. Cuando está completamente cargado es capaz de entregar
14000 J de energía. Esta energía equivale solo al 0,25% que almacenan las baterías,
pero es la equivalente a de la energía cinética para que el kart vaya a 45 km/h.
El motor del coche es un motor de 48Vdc de D&D Motor System. La
capacidad para variar la fuerza del campo eléctrico del motor es ajustable mediante la
curva par-velocidad. A bajas velocidades, el campo del motor entrega el par máximo
por cada amperio. A altas velocidades, el campo se debilita para reducir la fuerza
electromotriz que se genera y permite que el motor gire más rápido con la misma
tensión. La fuerza del campo se puede controlar de manera manual o automática. El
motor pesa 25 kg y puede llegar a producir 13 hp (10kw).
Ilustración 3.6 Motor del CapKart y esquema de protección
Ilustración 3.7 Caja del ultra-condensador
MEMORIA 21
3.2.2 TinyKart:
El tinyKart nace en el 5º campus de verano de Ingeniería del Centro Edgerton,
en el verano de 2011. Es un go-kart ultra ligero que se construyó como una alternativa
más pequeña del Cap Kart. El Cap Kart es ideal para conducir al aire libre, pero tenía
el inconveniente de que pesa 90 kg y con su tamaño no pasa a través de las puertas.
Por el contrario, el tinyKart pesa sólo 25 kg y puede ser transportado fácilmente por
una persona.
El primer paso para aligerar el peso respecto al Cap Kart fue crear un chasis
completamente con aluminio de 3 mm. de espesor. Además la parte delantera y trasera
pueden separarse con unos simples tornillos. Por lo que el chasis es mucho más
flexible y con la robustez suficiente para soportar el peso del kart con un conductor.
El sistema de tracción del tinyKart consiste en una batería especial de 39.6V,
6.9Ah LiFePO4, dos controladores de motores Kelly KBS36101 y dos motores
brushless EMP C6374-200. Los motores se conectan a los controladores Kelly
mediante unos sensores de efecto Hall. Las ruedas traseras reciben la transmisión
gracias a una correa.
3.2.3 Alexei 6x6:
El coche diseñado en el instituto Jaume I está diseñado principalmente para
niños pequeños. Su estructura consiste básicamente en un cajón de madera con el
diseño exterior que se le quiera dar. Su denominación 6x6 viene por las 6 ruedas que
Ilustración 3.8 Detalles del TinyKart
MEMORIA 22
lleva en total el coche. Tres por lado y todas ellas motrices, lo que hace que su
conducción sea similar a la de un vehículo oruga. Por lo que, a pesar de no tener una
alta velocidad si tiene una gran maniobrabilidad. Los motores son DC de 20A MD03.
Se puede controlar tanto sentado en el vehículo como a distancia, mediante una
conexión bluetooth (módem Bluetooth SmirfBlue) y una aplicación para Android.
Toda la electrónica está controlada por un Arduino Mega.
3.2.4 NeurotiKart:
La base de la construcción del NeurotiKart es un motor de carrito de golf de
48Vdc. Todo nace a partir de ahí. Se hizo una estructura con tubo redondo metálico,
todo soldado. Y para la dirección, tracción y frenado se utilizó material de los karts.
Ilustración 3.9 Detalles del Alexei 6x6
MEMORIA 23
Una vez analizados los distintos vehículos podemos observar a continuación
una tabla con sus características esenciales:
Modelo Tracción Dirección Control
CapKart Motor DC Manual Manual
TinyKart Motor Brushless Manual Manual
Alexei 6x6 6 Motores DC Manual / Automática Manual / Remoto
NeurotiKart Motor DC Manual Manual
Tabla 3.1 Comparativa vehículos ya construidos
Con estos datos se decidió que el prototipo iría impulsado por un motor DC y
su dirección y control tendrían la opción de elegir entre un control manual o remoto.
3.3 Diseño y construcción:
La idea para comenzar con el diseño del chasis era seguir el punto de partida que
habían usado la mayoría de proyectos similares. Partir de un chasis de kart y adaptarlo a las
necesidades.
Ilustración 3.10 NeurotiKart
MEMORIA 24
Lamentablemente, viviendo en Tenerife el acceso a las ofertas de segunda mano es
muy escaso, incluso buscando en la isla de enfrente, Gran Canaria, las ofertas eran escasas y de
precio elevado. Mientras que en la península era posible encontrar un kart completo desde
200€, aquí por 500€ solo se podía obtener el chasis de éste. A lo que habría que añadir luego el
sistema de dirección, de frenado, las ruedas y sus llantas, … lo que incrementaba bastante más
el precio inicial.
La alternativa que se encontró fue realizar un chasis, partiendo de cero, usando los
planos homologados por la Federación Internacional de Automovilismo (FIA).
La complicación que tenían los chasis regulados por la FIA es que toda la estructura se
ha de realizar con perfil tubular y en algunos tramos debe tener una curvatura específica.
Además de que aún usando este modelo de chasis habría que, posteriormente, adaptarlo para
el motor eléctrico, la disposición de las baterías y los elementos electrónicos.
Para evitar realizar un chasis tan laborioso y que llevaría muchas horas de trabajo en el
diseño y su construcción, a parte de tener que buscar un suministrador de los materiales; se
siguió buscando esquemas de chasis de karts caseros y que, preferiblemente, tuviesen líneas
simples y empleasen perfil hueco rectangular.
Ilustración 3.11 Componentes principales de un kart
MEMORIA 25
Las ventajas de encontrar un esquema de chasis con estas características significaría
ahorrar bastante tiempo en su fabricación. Al tener formas simples no haría falta ninguna
dobladora de tubos y el corte de los tubos sería, mayoritariamente de 45º, un corte muy simple
y fácil de realizar con una radial. Además, un perfil rectangular tiene una superficie de contacto
mayor y más continua, lo que hace que sea más fácil de soldar que el perfil tubular.
Idealmente recomiendan que los chasis de los vehículos se fabriquen con chasis
tubular para un mejor reparto de las fuerzas, pero en este proyecto no es fin hacer una
comparativa entre los distintos tipos de chasis sino que se busca el más sencillo de fabricar y, a
la vez, sea resistente.
Mientras se realizaban los diseños del chasis a fabricar se presentó la oportunidad de
poder aprovechar un miniquad que iba a ir al desgüace.
Los quads son vehículos de cuatro ruedas todo-terrenos (ATV, All-terrain vehicle)
parecidos a una motocicleta. Los quad proceden de los primeros triciclos (o hart-trick), los
cuales disponían de dos ruedas traseras y una delantera.
Ilustración 3.12 Planos de un chasis casero
MEMORIA 26
El quad ofrecido estaba indicado para personas inferiores a 1,70m., pues sus
dimensiones eran reducidas. Como sistema de frenado empleaba un disco de freno en el eje
trasero. En el interior del chasis, debajo del asiento del piloto, iba alojado un motor de 49cc.
de combustión interna. El sistema de tracción estaba compuesto por un piñón de 9 dientes en
el eje del motor, otro piñón, este de 32 dientes, en el eje trasero y una cadena, uniendo ambos
elementos, para transmitir el movimiento. Tanto el eje trasero como el delantero poseían un
muelle que ofrecía una suspensión independiente a los ejes del chasis central.
Ilustración 3.13 Distintas fotos del miniquad
MEMORIA 27
Con el quad en posesión cambió la forma de afrontar el diseño, ahora el objetivo era
aprovechar la mayor cantidad de elementos del quad para el vehículo eléctrico.
Después de realizar varios diseños se decidió aprovechar tanto el eje delantero como el
trasero y realizar un chasis central nuevo donde alojar las baterías, la electrónica y, en
principio, el motor.
Brazo dirección Electrónica y
router
Motor
Baterías
Ilustración 3.15 Organización del kart
Disco de freno
Asiento
Suspensión trasera
Motor
Suspensión delantera
Ilustración 3.14 Detalles del miniquad
MEMORIA 28
A la hora de buscar el soporte para el motor surgió el problema de instalar su tensor.
En los vehículos de tracción mediante cadena o correa, en el que el motor está en el chasis
central y el sistema llega hasta el eje trasero y éste tiene suspensión independiente, es necesaria
la instalación de un tensor. La finalidad del tensor es mantener siempre la cadena con tensión,
de forma, que aunque hayan irregularidades en el terreno siempre se asegure una tensión en la
cadena para que la transmisión sea óptima.
Para poder simplificar el sistema y ahorrar el montaje del tensor y su mantenimiento,
se decidió modificar el eje trasero de forma que pudiese colocarse el motor sobre esta pieza.
Realizando esto el motor oscilaría de la misma forma que el eje trasera y la cadena podrá
instalarse de forma parecida a una bicicleta convencional.
Otro punto a tener en cuenta para la fabricación del chasis era la dirección del
vehículo. Había que mantener la opción de poder manejar el vehículo mediante el manillar o
bien mediante un actuador eléctrico. Hubo que soldar un enganche al eje de la dirección y otro
Ilustración 3.16 Detalle del soporte para motor
MEMORIA 29
al chasis central para poder instalar el nuevo brazo de la dirección, además de alargar el
manillar para que fuese cómodo su manejo.
Para ayudar a minimizar el tamaño del chasis, en lugar de situar el asiento a ras del
chasis y detrás, o a los lados de éste las baterías, se decidió levantar el asiento y colocar las
baterías debajo, ganando de esta forma comodidad y facilidad en la conducción..
A parte de las modificaciones pertinentes para poder adaptar el vehículo al proyecto
hubo que realizarle una puesta a punto a las partes que se reutilizaron. Hubo que cambiar
todos los tornillos del coche debido a su mal estado y se aprovecharon para poner arandelas
en los tornillos que servían como anclaje para articulaciones y tuercas de seguridad en todos
ellos.
Ilustración 3.17 Manillar y brazo de la dirección
MEMORIA 30
Además el eje trasero estaba en muy malas condiciones, presentaba una desviación y
los cojinetes estaban en tan mal estado que provocan que se frenase el vehículo, se le realizó
una buena limpieza y engrase que provocó una gran mejora en el rendimiento. Antes de este
mantenimiento el eje girando en vacío necesita una corriente de 6 amperios, una vez realizada
la labor el consumo disminuyó hasta menos de 2 amperios.
Ilustración 3.18 Tornillos del vehículo.
MEMORIA 31
Una vez terminada la estructura del coche se procedió a su análisis para poder
encontrar los puntos a mejorar en un siguiente diseño.
Para empezar, su peso es excesivo, teniendo en cuenta que aún se debe de sentar una
persona. Un chasis de aluminio reduciría bastante el peso, incluso se podría combinar con
partes de PVC, como el soporte del asiento, que es aún más ligero.
Segundo, el sistema de cada eje con suspensión hace que su tamaño resulte algo
excesivo. Crear un chasis en el que los ejes estén integrados a éste lo haría más compacto y,
seguramente, más manejable.
Tercero, si no fuese necesaria la conducción manual, se podría prescindir del manillar,
simplificando el sistema de dirección.
Ilustración 3.19 Detalle del eje trasero
MEMORIA 32
Posiblemente para el siguiente diseño se parta de los prototipos basados en un
taburete y sin suspensión. De esta forma se eliminan los ejes independientes y la dirección se
coloca de forma vertical. El resultado es un vehículo más alto, pero más compacto y ligero.
Ilustración 3.20 Diseño del barstool
MEMORIA 33
4. DISEÑO DE LA ELÉCTRONICA DEL VEHÍCULO
La parte del diseño electrónico, selección de componentes, programación y realización
de PCBs es donde más tiempo se ha invertido de todo el proyecto.
En el se explican las funciones que se desean implementar y los componentes que se
han escogido para cumplir los requisitos. También se explican las pruebas de hardware que se
han realizado para verificar su funcionamiento y su implementación con la tarjeta de control
Arduino.
4.1 Idea general:
Como ya se ha explicado en capítulos anteriores se desea tener la posibilidad de poder
manejar el vehículo de diferentes maneras por lo que es necesario disponer de un elemento
que ofrezca la posibilidad de alternar entre los modos disponibles, también hay que
seleccionar los elementos que actúen como aceleradores y que permitan el movimiento de la
dirección. Además es necesario entregar información al usuario del estado de las salidas y
otros datos para que sepa que el funcionamiento es el correcto. A continuación se muestra un
esquema detallado de la idea general del apartado de la electrónica para poder escoger la placa
de Arduino que se adapte a las necesidades.
MEMORIA 34
En el gráfico anterior se muestran las salidas y entradas necesarias que deberá manejar
la placa de Arduino. A pesar de todos los modelos diferentes de placas de Arduino en la parte
del microprocesador solo se puede escoger entre dos alternativas.
Una vez elegida la placa hay que pensar como se organizará la electrónica. Para el
sistema de tracción y la dirección es necesario que el actuador gire en los dos sentidos, por ello
deben llevar una etapa previa denominada puente H. El conjunto de elementos para
seleccionar los distintos modos de funcionamiento, para órdenes de actuación al Arduino y
para mostrar información se situarán en una placa denominada panel de control.
uControlador Selector marcha (1 EA)
Selector modo (1 EA)
Acelerador moto (1 EA)
Thumb Joystick (2 EA)
Displays (12 SD)
Tracción (2 SA)
Dirección (2 SD)
LEDs control (7 SD)
Luces pulsador (1 ED)
Luces (1 SD)
Ilustración 4.1 Entradas y salidas necesarias
MEMORIA 35
Microprocesador Entradas
analógicas (EA)
Entradas/Salidas digitales
(ED/SD)
Salidas
analógicas (SA)
ATmega 328 6 14 6
ATmega 2560 16 54 14
Necesidades
5 1/22 2
Tabla 4.1 Entradas y salidas necesarias
Debido al elevado número de salidas digitales necesitadas se ha de escoger una placa
que tenga un microprocesador ATmega 2560 y la única placa que lo posee es la Arduino
MEGA 2560. Así que todo el desarrollo electrónico se centrará en torno a esta controladora.
4.2 Arduino MEGA 2560:
La placa Arduino MEGA 2560 es una placa basada en el microcontrolador ATmega
2560. Tiene 54 entradas/salidas digitales (de las cuales 14 pueden usarse como salidas PWM),
𝜇𝐶
Decodificador
Modo
Marcha
Luces
Thumb-Joystick
Acelerador moto
Puente H
Displays
Puente H
Tracción
Dirección
Ilustración 4.2 Estructura del programa
MEMORIA 36
16 entradas analógicas, 4 UARTS (puertos serial), una velocidad de reloj de 16MHz (1
instrucción ejecutada cada 62,5 microsegundos), conexión USB (tipo A) y un botón de reset.
• Pines de potencia:
La placa se puede alimentar tanto por el USB (5 voltios) como por el conector Jack de
2.1mm (la tensión positiva va al pin central y la tierra se sitúa fuera) que incorpora. La
selección de la alimentación la realiza el Arduino automáticamente.
Si se utiliza el conector Jack se puede alimentar en un rango de 6 a 20 voltios, aunque
lo recomendable es aplicar entre 7 y 12 voltios debido a que incorpora un regulador
7805 en su interior que se encarga de filtrar la entrada y obtener de ella 5 voltios
estables y filtrados. También se puede utilizar el pin denominado Vin para alimentar la
placa de la misma manera.
Los pines marcados como “5V” ofrecen una salida de 5 voltios para los elementos que
se conecten a la placa y sean aptos para esta alimentación.
El pin marcado como “3V3” ofrece una salida de 3,3 voltios y una corriente máxima
de 50mA.
Los pines marcados como “GND” sirven para conectar otros elementos a la tierra del
Arduino.
• Memoria:
El microcontrolador dispone de una memoria flash interna de 256kB para almacenar
el código de programa (aunque 8kB son usadas para el bootloader), también dispone
de 8kB de SRAM y 4kB de memoria EEPROM.
• Entradas y salidas:
Cada uno de los 54 pines del MEGA puede ser utilizado como entrada o salida,
trabajan a 5 voltios y pueden aportar o recibir un máximo de 40mA. También
disponen de una resistencia pull-up que viene desconectada por defecto. Además hay
ciertos pines que disponen de funciones extras:
Comunicación serial:
MEMORIA 37
Puerto Serial Rx (Recibe) Tx (Transmite)
0 0 1
1 19 18
2 17 16
3 15 14
Tabla 4.2 Conexiones Serial del Arduino
Interrupciones externas: Los siguientes pines se pueden configurar para interrupciones
externas y configurar su activación (flanco de subida, flanco de bajada, cambio de
estado, estado bajo).
Interrupción Pin
0 2
1 3
2 21
3 20
4 19
5 18
Tabla 4.3 Pines para interrupciones externas del Arduino
• PWM:
Los pines del 2 al 13 y del 44 al 46 ofrecen una salida PWM de 8 bits. Esto significa
que se puede conseguir una salida de valor “analógico” de entre 0 y 5 voltios con 256
(28) valores intermedios.
• SPI (Serial Peripheral Interface):
Los pines 50 (MISO), 51 (MOSI), 52 (SCK) y 53(SS) son los que se emplean para
establecer una conexión SPI.
Además para poder crear una comunicación del Arduino con cualquier dispositivo por
vía Ethernet debemos conectar la shield de Ethernet.
MEMORIA 38
4.3 Módulo Ethernet:
La Arduino Ethernet Shield permite a una placa Arduino conectarse a internet.
Está basada en el chip Ethernet Wiznet W5100. El Wiznet W5100 provee de una pila
de red IP capaz de TCP y UDP. Soporta hasta cuatro conexiones de sockets
simultáneas.
La Ethernet shield dispone de unos conectores que permiten conectar a su vez
otras placas encima y apilarlas sobre la placa Arduino.
Arduino usa los pines digitales 10, 11, 12, y 13 (SPI) para comunicarse con el
W5100 en la Ethernet shield. Estos pines no pueden ser usados para e/s genéricas.
La shield provee un conector Ethernet estándar RJ45.
El botón de reset en la shield resetea ambos, el W5100 y la placa Arduino.
Ilustración 4.3 Arduino Mega
Ilustración 4.4 Ethernet shield
MEMORIA 39
4.4 Panel de control:
El motivo de instalar un panel de control en el vehículo es que el usuario pueda
indicarle al microcontrolador en que modo desea que actúe, le envíe las órdenes de
movimiento y que además el microcontrolador pueda indicarle de forma lumínica el estado de
determinadas salidas.
A continuación se muestra un gráfico con los elementos que interactúan entre el
usuario y la placa de Arduino.
Ilustración 4.5 Elementos del panel de control
MEMORIA 40
4.4.1 Interruptor selector de modo:
El interruptor de selección de modo es un interruptor
rotativo de hasta 16 posiciones. Para este caso se ha configurado de
tal forma que solo puede acceder a 4 posiciones.
Su objetivo es que el usuario alterne entre sus estados para
seleccionar el modo en que quiere que trabaje el Arduino.
La conexión del switch se realizará de forma en la que se suelen conectar los
potenciómetros a los puertos analógicos, de esta forma en vez de ocupar 4 entradas
digitales solo emplearemos una única entrada y según su valor de tensión entraremos
en un modo u otro.
Lo primero que necesitamos hacer es saber la relación de los pines del
interruptor con las posiciones de éste.
Una vez obtenida la relación entre las entradas y las salidas seleccionamos los pines
de forma que se podamos elegir 4 posiciones distintas pero contiguas en la rotación.
Por ello se han escogido las siguientes:
Posición Pines
0
1
2
3
Tabla 4.4 Pines seleccionados
Ahora necesitamos obtener 4 valores de tensión más o menos equidistantes sabiendo
que tendremos una tensión de alimentación de 5 voltios.
Ilustración 4.6 Selector de modo
MEMORIA 41
En el gráfico anterior podemos observar los voltajes comprendidos entre los
distintos modos. Para calcular bien los valores de tensión utilizaremos la Ley de Ohm y la
fórmula para los divisores de tensión.
𝐿𝑒𝑦 𝑑𝑒 𝑂ℎ𝑚 → 𝑉 = 𝐼 · 𝑅
𝐷𝑖𝑣𝑖𝑠𝑜𝑟 𝑑𝑒 𝑡𝑒𝑛𝑠𝑖ó𝑛 → 𝑉!"# =𝑅!
𝑅! + 𝑅!· 𝑉!"
A continuación se muestra un gráfico con el esquema general de la conexión
para que se comprendan mejor los cálculos que se van a hacer.
Modo 1 Modo 2 Standby Remoto
0V 1,25V 2,5V 3,75V 5V
Ilustración 4.7 Voltajes para el selector de modo
Ilustración 4.8 Divisor de tensión
MEMORIA 42
Analizando el gráfico X.X (de los modos) podemos darnos cuenta de
que para el modo “Remoto” podemos emplear 5 voltios, por lo que nos sirve con
alimentar la entrada analógica del Arduino directamente.
También observamos que para el modo “Local 1” podemos poner la entrada a
0 voltios (tierra) y tendríamos preparada esa opción.
Entonces nos quedaría para los modos “Local 2” y “Standby”. Para ello
podemos calcular el valor en tercios de 5 voltios.
5 ·13 = 1,6667
5 ·23 = 3,3335
Comparando los valores de tensión obtenidos de esta forma con los
requeridos, se ha acertado en el cálculo y para el modo “Local 2” necesitaríamos un
divisor de tensión con una relación de 1/3 y para el modo “Standby” una relación de
2/3.
Hagamos ahora el cálculo utilizando la fórmula del divisor de tensión.
Ilustración 4.9 Conexiones del selector de modo
MEMORIA 43
𝐿𝑜𝑐𝑎𝑙 2 → 𝑉!"#$!! =𝑅!
𝑅! + 𝑅!· 𝑉!" → 𝑉!"#$!! · 𝑅! + 𝑅! = 𝑅! · 𝑉!"
→ 𝑉!"#$!! · 𝑅! + 𝑉!"#$!! · 𝑅! = 𝑅! · 𝑉!" → 𝑉!"#$!! · 𝑅!
= 𝑅! · 𝑉!" − 𝑉!"#$!! → 𝑅! = 𝑅! ·𝑉!" − 𝑉!"#$!!𝑉!"#$!!
→ 𝑅!
= 𝑅!5− 1,6671,667 → 𝑅! = 2,125𝑅!
Se ha obtenido como resultado que R2 debe ser 2,125 veces mayor que R4.
Calculemos ahora el valor para el modo “Standby”.
𝑆𝑡𝑎𝑛𝑑𝑏𝑦 → 𝑉!"#$%&' =𝑅!
𝑅! + 𝑅!· 𝑉!" → 𝑉!"#$%&' · 𝑅! + 𝑅! = 𝑅! · 𝑉!"
→ 𝑉!"#$%&' · 𝑅! + 𝑉!"#$%&' · 𝑅! = 𝑅! · 𝑉!" → 𝑉!"#$%&' · 𝑅!
= 𝑅! · 𝑉!" − 𝑉!"#$%&' → 𝑅! = 𝑅! ·𝑉!" − 𝑉!"#$!"#𝑉!"#$%&'
→ 𝑅!
= 𝑅!5− 3,3353,335 → 𝑅! = 0,499𝑅!
Se ha obtenido como resultado que R3 debe ser 0,499 veces mayor que R4.
El valor de R4 se escoge según convenga, en este caso escogeremos 3k65
Ohms. Por lo que nos quedan los siguientes resultados:
𝑅! = 2,125 · 𝑅! = 2,125 · 3650 = 7756 𝑂ℎ𝑚𝑠
𝑅! = 0,499 · 𝑅! = 0,499 · 3650 = 1821,35 𝑂ℎ𝑚𝑠
Lamentablemente los valores obtenidos no son valores comerciales que
disponemos por lo que tenemos que aproximar a los valores disponibles más cercanos,
obteniendo al final:
𝑅! = 7500 𝑂ℎ𝑚𝑠
𝑅! = 2000 𝑂ℎ𝑚𝑠
De nuevo calculamos las tensiones de salida para comprobar que se cumplen
los requisitos:
MEMORIA 44
𝐿𝑜𝑐𝑎𝑙 2 → 𝑉!"#$!! =𝑅!
𝑅! + 𝑅!· 𝑉!" =
36507500+ 3650 · 5 = 1,63𝑉
𝑆𝑡𝑎𝑛𝑑𝑏𝑦 → 𝑉!"#$%&' =𝑅!
𝑅! + 𝑅!· 𝑉!" =
36502000+ 3650 · 5 = 3,23𝑉
Como era de esperar, se obtienen las tensiones necesitadas.
Para el valor de la resistencia del modo “Local 1” basta con que pongamos una
resistencia de 33k Ohms que al tener 10 veces el valor de R4 actuará dividiendo entre
10 la tensión de 5 voltios.
Ahora calculamos el valor de la tensión de salida:
𝐿𝑜𝑐𝑎𝑙 1 → 𝑉!"#$!! =𝑅!
𝑅! + 𝑅!· 𝑉!" =
365033000+ 3650 · 5 = 0,49𝑉
Y para finalizar, en el modo “Remoto” no añadimos ninguna resistencia y dejamos
que lleguen los 5 voltios directos a la entrada del Arduino.
• Pruebas de verificación de hardware.
Siguiendo el esquema representado en la figura X.X (esquema de fritzing) y
con los componentes que se han calculado se realiza el siguiente montaje en
una protoboard.
MEMORIA 45
La prueba para verificar que el circuito funciona correctamente consiste en
colocar un multímetro entre el nodo de unión de todas las resistencias y tierra.
Se verifica que el esquema muestra los valores calculados.
• Diseño del software:
Arduino tiene un comando llamado “map” que resulta muy útil para este caso.
El comando map se invoca de la siguiente manera:
Variable1 = map(variable1, fromLow, fromHigh, toLow, toHigh)
o value: el número (valor) a mapear.
o fromLow: el límite inferior del rango actual del valor.
o fromHigh: el límite superior del rango actual del valor.
o toLow: límite inferior del rango deseado.
o toHigh: límite superior del rango deseado.
En nuestro caso:
SELECTOR_POS = map(SELECTOR_POS, 0, 1023, 0, 3)
Ilustración 4.10 Conexiones del selector de modo en la protoboard
MEMORIA 46
Con esto se consigue que los 1024 valores que tiene el conversor A/D de la
entrada analógica se agrupen en 4 bloques. Por eso se seleccionaron los valores
de resistencia anteriores.
A continuación se muestra el código implementado para su funcionalidad.
void loop(){
//En el programa principal se chequea continuamente el valor del
interruptor de modo y según su posición se va a una rutina u otra.
SELECTOR_POS = analogRead (SELECTOR); //Variable
para guardar la posicion del selector de modo
SELECTOR_POS = map (SELECTOR_POS, 0, 800, 0, 3);
//Mapeamos el valor para tener solo 4 casos
switch (SELECTOR_POS) { //Segun sea el valor
iremos a un caso o a otro
case 0:
local1(); //Vamos al modo local1
break; //Salimos del switch
case 1:
local2(); //Vamos al modo local2
volante(); //Vamos a la dirección
break;
case 2:
standby(); //Vamos al modo standby
break;
case 3:
remoto(); //Vamos al modo remoto
MEMORIA 47
break;
};
Lo bueno de emplear el comando map, es que nos da una salida que solo
variará entre 4 únicos valores y resulta bastante óptimo si se emplea junto al
comando switch. De no haberlo usado tendríamos que haber implementado un
código preguntando siempre por el valor y viendo si se cumple la condición de
que la tensión de entrada esté dentro de los umbrales que deseemos.
void loop(){
//En el programa principal se chequea continuamente el valor del
interruptor de modo y según su posición se va a una rutina u otra.
SELECTOR_POS = analogRead (SELECTOR); //Variable
para guardar la posicion del selector de modo
if (SELECTOR_POS < 256)
local1();
else if (SELECTOR_POS >= 256 && SELECTOR_POS < 512)
local2();
else if (SELECTOR_POS >= 512 && SELECTOR_POS < 768)
standby();
else
remoto();
};
Se puede apreciar como, a pesar de funcionar perfectamente, la forma
implementada es más óptima y clara. Si por ejemplo quisiésemos ir al modo
“Remoto” con switch iríamos directamente mientras que en el último código
primero miraríamos si el valor esta en “Local 1”, luego en “Local 2” y
“Standby” para al final comprobar que se puede entrar en “Remoto”. El
MEMORIA 48
programa entraría pero se ha realizado de una forma que tarda más tiempo en
entrar.
4.4.2 Interruptor selector marcha:
Cuando nos encontramos en el modo “Local 1” solo usamos el
acelerador de moto para dar potencia al motor pero no tenemos ninguna
forma de decir si queremos ir avanzar, parar o retroceder. Por eso se ha
instalado un interruptor con el que poder elegir entre estas tres opciones.
La conexión del interruptor seguirá la misma metodología que en el
interruptor de selección de modo pero en este caso es mucho más sencillo y se
conectará a la entrada analógica A1. Seguiremos aplicando la misma filosofía que en el
caso anterior, aprovechar una entrada analógica para poder leer los distintos valores.
Como solo necesitamos 3 valores y viendo que antes pudimos aprovechar los
dos valores de los extremos solo nos hará falta calcular un valor de tensión. El valor
más fácil de calcular es la mitad, 2.5 voltios.
Marcha Tensión Conexión
Avance 0 Voltios Tierra
Paro 2,5 Voltios Divisor de tensión
Retroceso 5 Voltios Directa
Tabla 4.5 Conexiones selector de marcha
Hay una regla no escrita para los divisores de tensión y que se cumple siempre para
hallar la mitad de una tensión. Siempre que queramos obtener la mitad de la tensión de
entrada debemos colocar en serie dos resistencias iguales, de esta forma caerá la misma
tensión en las dos resistencias y obtendremos la salida esperada. A continuación se hace el
desarrollo teórico y se enseña el esquema de la conexión.
Ilustración 4.11 Selector de marcha
MEMORIA 49
𝑃𝑎𝑟𝑜 → 𝑉!"#$ =𝑅!
𝑅! + 𝑅!· 𝑉!" → 𝑉!"#$ · 𝑅! + 𝑅! = 𝑅! · 𝑉!" → 𝑉!"#$ · 𝑅! + 𝑉!"#$ · 𝑅!
= 𝑅! · 𝑉!" → 𝑉!"#$ · 𝑅! = 𝑅! · 𝑉!" − 𝑉!"#$ → 𝑅! = 𝑅! ·𝑉!" − 𝑉!"#$𝑉!"#$
→ 𝑅! = 𝑅!5− 2,52,5 → 𝑅! = 𝑅!
Observamos como matemáticamente se cumple lo que se dijo anteriormente.
• Pruebas de verificación de hardware.
Siguiendo el esquema representado en la figura X.X (esquema de fritzing) y
con los componentes que se han calculado se realiza el siguiente montaje en
una protoboard.
Ilustración 4.12 Conexiones selector de marcha
MEMORIA 50
Y al igual que con el ejemplo anterior, con la ayuda de un multímetro se
comprueba que obtenemos las tensiones calculadas.
• Diseño del software:
void loop(){
int sentido_pos = analogRead (SENTIDO); //Leemos el
selector de avance-paro-retroceso
sentido_pos = map (sentido_pos, 0, 1023, 0, 2); //Mapeamos el
valor para asignarlo a nuestras 3 opciones
switch (sentido_pos){
//En el caso de que tengamos un 0 iremos a avance(), con un 1
iremos a paro() y con un 2 iremos a retroceso().
case 0:
avance();
break;
case 1:
paro();
break;
case 2:
Ilustración 4.13 Conexiones del selector de marcha en la protoboard
MEMORIA 51
retroceso();
break;
}
}
4.4.3 Acelerador de moto:
En el modo “Local 1” gobernaremos el coche con el
interruptor de selección de marcha y un acelerador de moto
instalado en el manillar. Este acelerador no es más que un
potenciómetro colocado en una empuñadura y con retorno al
origen. Su conexión se realizará en la entrada analógica 2.
Para este componente no hace falta realizar ningún cálculo. Solo es necesario
conectarlo adecuadamente e implementar el código. La conexión se muestra en el
siguiente diagrama:
• Diseño del software:
void loop (){
int valor = analogRead (pot)/4;
analogWrite(motor, valor);
Serial.println (valor);
} Para tener una forma fácil de comprobar que la implementación no tiene
ningún error imprimimos por la consola serial el valor que se lee del potenciómetro.
Ilustración 4.14 Acelerador de moto
Ilustración 4.15 Conexiones acelerador de moto
MEMORIA 52
Nos debe de dar un valor de 0 para 0 voltios y 1023 para 5 voltios. Si la placa donde se
realiza la prueba tiene holguras o algunas conexiones flojas es posible que los valores
varíen constantemente entre valores próximos.
4.4.4 Thumb joystick:
Si se ha seleccionado la opción para que la tarjeta Arduino
trabaje en el modo “Local 2” esto implica que tendremos que utilizar
como medio de control tanto para la tracción como para la dirección el
thumb joystick.
Este joystick está formado por dos potenciómetros, uno se
desplaza en el eje Y y otro en el eje X. Tiene la ventaja de que siempre
retorna al punto medio de los dos ejes.
En el eje Y se implementa el control de la tracción y en el eje X la dirección
eléctrica del vehículo, de esta forma el control resultará más natural pues se asemeja al
control de un coche teledirigido.
Al igual que en el caso del acelerador de moto, colocaremos la salida de los
potenciómetros en las entradas analógicas. Se asignará el pin A3 para la tracción y A4
para la dirección tal y como se muestra en el diagrama.
Hay que señalar los dos interruptores de fin de carrera que se deben colocar en
los extremos del actuador lineal para que cuando ha llegado a los extremos, el control
no siga enviando tensión y provoque que se rompa el actuador.
Eje X = Dirección
Eje Y = Tracción
Ilustración 4.16 Thumb joystick
Ilustración 4.17 Ejes del thumb joystick
MEMORIA 53
Estos dos interruptores deben de tener una resistencia de 10k conectada a tierra que
actúa en configuración pull-down, con esto se asegura que cuando no esté cerrado el pin
del interruptor esté a 0 voltios.
• Diseño del software:
En este caso la parte del hardware no tiene ningún problema sin embargo en el
código es más complejo.
Ilustración 4.18 Conexiones thumb joystick e interruptores fin de carrera
Ilustración 4.19 Conexiones thumb joystick en la protoboard
MEMORIA 54
Debemos dejar claras las pautas comportamiento para el comportamiento de
los potenciómetros.
void local2(){
JOYSTICK_TRAC_POS = analogRead (JOYSTICK_TRAC);
//Miramos la posicion del eje Y del joystick
if (JOYSTICK_TRAC_POS < 500) //Si el valor que
leemos del joystick es menor que 500, quiere decir que tenemos el
joystick bajado y vamos a retroceso()
retroceso();
else if (JOYSTICK_TRAC_POS > 525) //Si el valor que
leemos del joystick es mayor que 525, quiere decir que tenemos el
joystick subido y vamos a avance()
avance();
else //De lo contrario, si el joystick se
encuentra entre 500 y 525, no estamos tocando el jooystick y vamos
a paro()
paro();
}
void volante () {
int posgiro1 = analogRead (JOYSTICK_DIRE); //Creamos
una variable interna para leer el valor del eje X del joystick
Derecha
X>=525
Izquierda
X<=500
Avance
Y>=525
Paro
487<Y<525
Retroceso
X<=487
Ilustración 4.20 Valores de los potenciometros para las acciones
MEMORIA 55
if (posgiro1 < 500 && digitalRead (GIRO_IZQUIERDA_TOPE) ==
HIGH ) { //Si tenemos el joystick girado a la izquierda y no está
activo su FDC entramos en el bucle
digitalWrite (GIRO_DERECHA, LOW); //Apagamos
el led de giro a la derecha
digitalWrite (GIRO_IZQUIERDA, HIGH); //Encendemos
el led de giro a la izquierda
}
else if (posgiro1 > 525 && digitalRead (GIRO_DERECHA_TOPE)
== HIGH) { //Si por el contrario tenemos el joystick girado a la
derecha y no está activo su FDC entramos en el bucle
digitalWrite (GIRO_IZQUIERDA, LOW);
//Apagamos el led de giro a la izquierda
digitalWrite (GIRO_DERECHA, HIGH);
//Encendemos el led de giro a la derecha
}
else { //En cualquier otro
caso, siginifica que no estamos moviendo el joystick sobre el eje X
digitalWrite (GIRO_IZQUIERDA, LOW); //Ponemos a
baja la salida del giro a la izquierda
digitalWrite (GIRO_DERECHA, LOW //Ponemos a
baja la salida del giro a la derecha
}
}
4.4.5 Displays 7 segmentos:
Para ayudar a una mejor experiencia de conducción se ha
creado un pequeño panel formado por 3 displays de 7 segmentos
para que el usuario sepa en cada momento la posición en que se
encuentra el acelerador para saber si el vehículo está respondiendo
como el desea o todavía puede exigir más rendimiento. Ilustración 4.21 Displays
de 7 segmentos
MEMORIA 56
Un display 7 segmento está formado, como su nombre indica, por 7 segmentos
que se pueden encender o apagar individualmente. Y cada segmento tiene forma de
línea.
Aunque externamente su forma difiere considerablemente de un diodo LED
(diodos emisores de luz) típico, internamente están constituidos por una serie de
diodos LED con unas determinadas conexiones internas, estratégicamente ubicados de
tal forma que forme un número 8.
A cada uno de los segmentos que forman el display se les denomina a, b, c, d,
e, f y g y están ensamblados de forma que se permita activar cada segmento por
separado consiguiendo formar cualquier dígito numérico.
Además se usará un decodificar BCD/7 segmentos entre la tarjeta Arduino y
cada display. El uso de un decodificador significa un ahorro importante de pines. Si
activásemos directamente los segmentos desde el Arduino utilizando los 3 displays
necesitaríamos 21 pines (7 pines · 3 displays) sin embargo, al utilizar codificadores de
binario a decimal solo necesitamos 12 pines (4 pines · 3 displays).
Un decodificador BCD/7 segmentos se encarga de traducir un número en
binario (Binary Code Decimal) para activar las salidas correspondientes en el display y
que su representación sea la correcta.
Ilustración 4.22 Conexiones de los displays
MEMORIA 57
A continuación se muestra una tabla con el número en decimal, en binario y las
salidas del display.
Decimal Binario Display
A B C D a b c d e f g
0 0 0 0 0 1 1 1 1 1 1 0
1 0 0 0 1 0 1 1 0 0 0 0
2 0 0 1 0 1 1 0 1 1 0 1
3 0 0 1 1 1 1 1 1 0 0 1
4 0 1 0 0 0 1 1 0 0 1 1
5 0 1 0 1 1 0 1 1 0 1 1
6 0 1 1 0 1 0 1 1 1 1 1
7 0 1 1 1 1 1 1 0 0 0 0
8 1 0 0 0 1 1 1 1 1 1 1
9 1 0 0 1 1 1 1 0 0 1 1
Tabla 4.6 Valores para un display
Como se aprecia en la tabla anterior es necesario 4 salidas para poder disponer
de los números del 0 al 9. Con 3 salidas tendríamos solo hasta 7.
Para el proyecto se han escogido displays de cátodo común en lugar de ánodo
común. Como su nombre indica, todos los segmentos tienen el cátodo común. Esto
significa que siempre están conectados a tierra y se activan cuando se cierra el circuito
en su cátodo, tal y como se muestra en la siguiente imagen.
MEMORIA 58
Conforme se han elegido los displays de cátodo común, es necesario que el
decodificador sea compatible con éstos. Para ello se ha escogido el circuito integrado
HCF4511.
Como ya se ha descrito anteriormente, este circuito traducirá la salida en
binario del Arduino para que se muestra el número que corresponda sobre los
displays.
A continuación se muestra el esquemático realizado para el funcionamiento del
mismo.
Este chip presenta tres patillas adicionales para activar o desactivar el display,
probar todos los segmentos o que parpadee. Haciendo caso al datasheet para que el
display funcione correctamente la patilla (5) Lamp Enable debe estar a tierra (0 voltios)
y las patillas (4) Blanking Input y (3) Lamp Test Input a alta (5 voltios).
4.4.6 Panel LED informativo:
Se decidió implementar una serie de LEDs para poder informar al
conductor el estado de conducción del vehículo. Estos indicarían las salidas
correspondientes al sistema de tracción y de dirección del vehículo.
Se optó por elegir LEDs del tipo SMD que ocupan un espacio
menor y ofrecen una luminosidad igual que un LED THD.
Los colores escogidos fueron blanco, azul, verde y rojo y su colocación y
significado se pueden ver en la siguiente imagen.
Ilustración 4.23 Conexión display cátodo común
Ilustración 4.24 LED SMD
MEMORIA 59
Según el color de cada LED el consumo de tensión y corriente es distinto, así que
ahora se realizará el cálculo aplicando la Ley de Ohm (V=I·R) para que cada LED tenga su
resistencia adecuada y no se funda.
Color Tensión Corriente Resistencia Valor comercial
Azul 3-3,3 20mA 𝑅 =
3,30,02 = 165Ω
150 Ω
Blanco 3,0-3,2 20mA 𝑅 =
3,20,02 = 160Ω
150 Ω
Rojo 2,1-2,3 20mA 𝑅 =
2,30,02 = 115Ω
91 Ω
Verde 3,2-3,4 20mA 𝑅 =
3,40,02 = 170Ω
150 Ω
Tabla 4.7 Valores resistencias para los LEDs
Tracción avance
Giro derecha
Tope derecha
Giro izquierda
Tope izquierda
Paro
Tracción retroceso
Ilustración 4.25 Posición LEDs indicadores
MEMORIA 60
4.4.7 PCB Panel de Control:
En un principio se diseñó una PCB a doble cara con todos los componentes
nombrados anteriormente para que el Servicio de Electrónica la implementase pero
debido a problemas en la tramitación se tuvo que modificar el diseño para poder
realizarlo uno mismo, pues no se disponía de insoladora a doble cara.
Es por ello que el diseño se partió en 4 módulos. El Thumb Joystick iría en un
módulo, los LEDs informativo en otro, el interruptor selector de modo, de marcha y
el pulsador de luces en un tercero y por último los displays en otro más.
De todas formas en los anejos del proyecto se incluyen los esquemas y diseños
para realizar el panel de control tanto con tecnología THD y displays de cátodo común
como con tecnología SMD y displays de ánodo común.
4.5 Sistema de dirección:
Para el sistema de dirección automático del coche se plantearon diversas opciones de
implementación.
Ilustración 4.26 Diseño PCB para el panel de control
MEMORIA 61
La primera opción que se manejó fue crear un pequeño sistema hidráulico. Para la
implementación de este sistema era necesario añadir una serie de elementos extras para que el
sistema funcionase. Estos componentes se pueden apreciar en la siguiente imagen:
El problema de este sistema es que, a parte de resultar bastante caro, necesita tener una
presión constante en el sistema de forma que el sistema reaccione de forma casi instantánea.
Depósito
Bomba
Filtro de
presión
Válvula descarga
Válvula Selección
Cilindro
Ilustración 4.27 Sistema de dirección hidraúlico
MEMORIA 62
Por motivos similares también se desecho el implementar un circuito neumático.
La siguiente alternativa sopesada fue añadir un servomotor como los utilizados en
aeromodelismo. Estos motores tienen la gran ventaja de tener un cable de control que envía
un señal codificada (un pulso PWM) indicándole la posición en la que debe situarse.
El problema que presentan es que su capacidad de esfuerzos es limitada y además se
necesitaría crear una estructura específica para él en el chasis.
La opción que se observó que podía rendir de forma más óptima era instalar un
actuador lineal. Un actuador lineal eléctrico es un dispositivo que convierte el movimiento de
Ilustración 4.28 Funcionamiento de un servomotor
MEMORIA 63
rotación de un motor de corriente continua de baja tensión en movimiento lineal, es decir, los
movimientos de empuje y tiro.
De las opciones que ofrecía el mercado se optó por escoger el modelo A-track 1 de X
mm de extensión y 24 voltios de alimentación de la compañía Warner Electric.
La elección de escoger el actuador de 24 voltios en lugar de 12 voltios fue debido a
que la corriente que demandará será menor pues la potencia es igual al producto de la tensión
por la corriente (P = V· I), por lo que para la misma potencia a mayor tensión menos
corriente será necesaria.
Esta elección también venía condicionada por el controlador que se iba a utilizar para
la acción de extensión y retracción. Un puente H implementado por el circuito integrado
L298N. Este chip es capaz de aguantar picos de 3 amperios y una carga constante de 2
amperios. Además de soportar hasta 50 voltios en su entrada. A continuación se pueden
observar los valores máximos del L298N y una foto de éste.
Ilustración 4.29 Actuador eléctrico para la dirección
Ilustración 4.30 Puente H con LM298 y datos técnicos
MEMORIA 64
Sabiendo que el controlador del actuador tenía esas características se miró en los datos
del fabricante las cargas que exigían los modelos de actuadores (el de 12 voltios y el de 24).
Se puede apreciar claramente como para una misma carga la corriente exigida en el
caso del actuador de 12 voltios llega a ser el doble que para el otro modelo, además de que con
el segundo modelo nunca se llegará a trabajar en los valores máximos del controlador.
Además el sistema de dirección dispondrá de dos interruptores fin de carrera para
indicar cuando se ha alcanzado el giro total de la dirección y no se continúe enviando señal al
actuador tal y como se aprecia en el siguiente esquema:
Ilustración 4.31 Rectas de carga del actuador eléctrico
MEMORIA 65
Cuando se instaló el sistema de dirección se hizo patente la falta de resistencias pull-down en
los interruptores fin de carrera para que la señal que recibiese el Arduino correspondiese
exactamente con el valor que debía emitir el interruptor.
Con la resistencia pull-down forzamos a que la entrada esté siempre a baja a no ser que
el interruptor se cierre y deje pasar la corriente. Son de vital importancia para evitar cambios
de estado producidos por ruidos eléctricos o variaciones en la fuente de alimentación.
Actuador
Fin de carrera
L298N
Arduino
Alimentación
Ilustración 4.32 Sistema de dirección del vehículo
MEMORIA 66
4.6 Sistema de tracción:
Todo el diseño de tracción gira en torno al motor que iría instalado en el coche. Lo
primero que se tuvo que decidir fue elegir el tipo de motor a emplear de corriente continua, de
corriente continua e imanes permanentes o paso a paso. La elección fue un motor de imanes
permanentes cuyas características principales se muestran en la siguiente tabla:
Características 800W / 36V
Consumo sin carga < 2,8 A
RPM sin carga 3500
Par 2,8 Nm
RPM con carga 2800
Corriente con carga < 27ª
Eficiencia > 78%
Tabla 4.8 Datos técnicos del motor
Ilustración 4.33 Resistencia pull-down del interruptor fin de carrera
MEMORIA 67
Los motores de imanes permanentes no tienen un devanado de campo en el bastidor
del estator, en lugar de éste se colocan una serie de imanes permanentes para proporcionar el
campo magnético contra el que interactúa el campo del rotor para producir par. Debido a que
este campo es fijo, no se puede ajustar para controlar la velocidad de giro del motor. Los
motores con imanes permanentes son convenientes en motores en miniatura para eliminar el
consumo de energía del devanado de campo.
Para minimizar el peso y el tamaño general, se pueden utilizar imanes de alta energía a
base de neodimio u otros elementos, la mayoría como son la aleación de neodimio-hierro-
boro.
Las ventajas que ofrecen los motores dc frente a un motor paso a paso es que su
control se implementa de forma más sencilla y el cambio en el sentido de giro y de aceleración
es mucho más rápido. Por su parte, los motores paso a paso nos ofrecen un control casi total
sobre ellos, pudiéndoles indicar en todo momento cuanto queremos avanzar y además
ofreciendo mucho más par.
Buscando por los distintos vendedores de motores se pudo observar que para las
características que se exigían (mover un peso bastante elevado con agilidad) lo más indicado
era utilizar un motor dc, pues a duras penas existe algún modelo de motor paso a paso
económico para mover los aproximados 120 kilos del vehículo y su ocupante.
Leyendo referencias de otros karts eléctricos construidos muchos han elegido un
motor de 24 voltios y 250 watios. Debido al elevado número de proyectos con este motor se
decidió escoger en un primer momento ese modelo.
MEMORIA 68
Más adelante, cuando se realizaron las primeras pruebas se comprobó que ese motor
era insuficiente para este proyecto y al final se tuvo que obtener uno nuevo. En este caso sería
un motor de 36 voltios y 800 watios.
Ilustración 4.34 Primer motor utilizado
Ilustración 4.35 Comparación entre el primer motor y el segundo
MEMORIA 69
Como el nuevo motor no estuvo contemplado desde el principio, al acoplarlo se
presentó un nuevo problema. Su longitud era tan grande que en la posición que se situó
rozaba con el neumático trasero izquierdo por lo que se tuvo que limar los tacos de la rueda
que se veían afectados.
4.6.1 Puente H:
El puente H o H bridge es la solución en sistemas donde el sentido de giro es una
necesidad de operación. En el diseño del puente H influyen numerosos factores como la
inercia del sistema mecánico, la velocidad en respuesta, el sistema de frenado, …
También conocido como puente completo, adopta la letra H para su nombre debido a la
forma que presenta dentro de un circuito esquemático simplificado, como se observa debajo. En
la barra central se encuentra ubicado el motor y en cada “rama lateral” ascendente o descendente
se ubican los conmutadores que, activados de una manera apropiada, brindarán al sistema los
movimientos necesarios para que el motor pueda girar en un sentido u otro.
Ilustración 4.36 Desgaste en el neumático para la colocación del motor
MEMORIA 70
Como se observa en la imagen existen 4 interruptores que se deben manejar de forma
apropiada para lograr el giro adecuado del motor.
movimientos sobre el motor
Para conectar el motor y hacerlo girar se deben activar las llaves de conmuntación por
pares opuestos en lo que respecta a los lados y a posición (superior o inferior). Un error en la
activación que permita la conexión de elementos superiores e inferiores de un mismo lado
provocará que permita la conexión de elementos superiores e inferiores de un mismo lado
provocará una descarga muy rápida de las baterías o, en el peor de los casos, destruirá los
elementos que forman las llaves conmutadoras. Para un giro seguro en uno de los dos
sentidos, debemos cerrar SW1 y SW3 (línea roja), observando que SW2 y SW4 (línea azul)
SW2
SW3 SW4
SW1
M
Lado Superior Derecho
(HSR)
Lado Inferior Izquierdo
(LSL)
Lado Inferior Derecho
(LSR)
Lado Superior Izquierdo
(HSL)
+VCC
SW2
SW3 SW4
SW1
M
Lado Superior Derecho
(HSR)
Lado Inferior Izquierdo
(LSL)
Lado Inferior Derecho
(LSR)
Lado Superior Izquierdo
(HSL)
+VCC
Ilustración 4.37 La letra H formada por la ubicación de los conmutadores en el circuito
Ilustración 4.38 Circulación de la corriente según las llaves que se cierren
MEMORIA 71
permanezcan abiertos. En el caso inversio sería SW2 y SW4 cerradas, mientras que SW1 y
SW3 deberán permanecer abiertas.
Para poder operar con el motor permitiendo un funcionamiento de giro en ambos
sentidos se sustituirán las llaves conmutadoras por transistores MOSFET. Existen diseños con
transistores de canal P en los lados superiores y de canal N para los inferiores. La ventaja de
este concepto de diseño es que las tensiones necesarias para activar los gates de los
transistores de canal P se podrán sacar directamente de la alimentación utilizada para el motor.
También se puede utilizar transistores de canal N en los lados superiores del puente. En esta
caso la tensión necesaria para activar los gates deberá provenir de un elevador de tensión que
funcione por encima del valor nominal de alimentación del motor.
El primer modelo de puente H que se realizó para el proyecto se describe en la imagen
siguiente:
Para obtener un giro determinado se emplearon 4 transistores MOSFET IRFZ44N de
canal N y que deberán comportarse como llaves conmutadoras. Tal como se desprende de la
hoja de datos del transistor para que conduzca a pleno, ofreciendo la menor resistencia entre
el drenador y la fuente, la tensión de puerta respecto a la fuente deberá ser más positiva y del
orden de los 2 a 4 voltios.
Lado Superior Derecho
(HSR)
IRFZ44N
M
Lado Inferior Izquierdo
(LSL)
Lado Inferior Derecho
(LSR)
Lado Superior Izquierdo
(HSL)
+VCC = 36V
IRFZ44N
IRFZ44N IRFZ44N
Ilustración 4.39 Primer puente H creado
Ilustración 4.40 Datos necesarios para el funcionamiento de los MOSFETs
MEMORIA 72
Atendiendo a los datos que ofrece el fabricante de los mosfet que estima una caída de
tensión entre drenador y fuente de 1,3 voltios y que la tensión suministrada por las baterías
será de 36 voltios (un poco más en plena carga), al motor le llegarán aproximadamente 34,7
voltios. Lo ideal sería poder obtener 36 voltios en el motor pero no se puede obtener otro
voltaje debido a la limitación que ofrecen las baterias.
Para que en la fuente puedan existir los 34,7 voltios teóricos, en la puerta se deben de
aplicar una tensión entre 36,7 y 38,7 voltios, es decir, entre 2 y 4 voltios por encima de la
tensión de la fuente. De lo contrario, la tensión necesaria para activar el transistor a la máxima
conducción se descontará de la tensión de alimentación y al motor le llegarán 32,7 voltios o
menos. De este modo, se tendrá una máxima circulación de corriente a través de drenador-
fuente para hacer girar el motor al máximo, con una diferencia de potencial de 2 voltios o más
entre estos dos terminales del transistor. Esto, equivale, según la fórmula de la potencia, que 2
voltios multiplicados por la máxima corriente del motor será la potencia que disipará en forma
de calor el transistor.
En un caso ideal del motor a pleno rendimiento, estarán circulando a través de él 28
amperios. Aplicando la fórmula de la potencia, habría una disipación de 56 watios,
redondeando 60 watios. Cada transistor es capaz de soportar 49 amperios, pero solo 50 watios
de disipación debido a su encapsulado. En principio con 2 transistores en paralelo debería
funcionar el sistema correctamente porque cada uno disiparía 30 watios pero para más
seguridad se ha decidido colocar 5 mosfets en paralelo, disipando cada uno 12 watios que está
por debajo del umbral de seguridad que establece el fabricante. Esta condición de seguridad
dice que para una mayor duración de los transistores éstos solo trabajen a un 40% de la
potencia máxima que soporten (20 watios).
Una alternativa para no tener un menor voltaje en el motor es la incorporación en el
sistema de un elevador de tensión dc-dc que aumente los dos voltios necesarios para elevar la
tensión en las puertas.
Para controlar la apertura de las puertas y con ello el sentido de giro y la velocidad del
motor se utilizará PWM. El problema es que como se ha comentado anteriormente, las
puertas necesitan un voltaje aproximado de 35 voltios y el Arduino solo es capaz de entregar
un PWM de 5 voltios de amplitud.
MEMORIA 73
Para solucionar este problema se creó la etapa amplificadora con transistores BJT que
se muestra en la siguiente imagen.
A continuación se detalla el funcionamiento de la etapa. Lo primero que cabe reseñar
es que los dos transistores son complementarios. El BD139 es NPN y el BD140 PNP. El
primer transistor se encarga de dejar pasar la tensión de 36 voltios en periodos inversos a la
señal de PWM que envía el Arduino debido a su configuración NPN. Por su parte el transistor
PNP se encarga de invertir la señal que genera el transistor BD139, ofreciendo de esta forma
un pulso idéntico al que introduce el Arduino pero con una tensión de pico de 36 voltios. A
continuación se muestran dos gráficas. La primera con una frecuencia de PWM de 500 Hz que
es el PWM que genera el Arduino sin modificar sus registros y la segunda con una frecuencia
de 31374 kHz. El color amarillo corresponde a la tensión en la base del transistor Q1, el color
azul al colector del mismo transistor y el rojo al colector del transistor Q2.
Ilustración 4.41 Etapa BJT
MEMORIA 74
Se comprueba como en la segunda gráfica los tiempos de subida y bajada en los
transistores afectan al rendimiento pues su zona de trabajo óptima es hasta los 20 kHz. A
pesar de estos problemas que generan los 31374 kHz en los transistores se decidió probar la
etapa con el motor, creando el siguiente montaje y obteniendo el resultado que se muestra a
continuación:
Se comprueba como los transistores no logran cerrar del todo debido a la alta
frecuencia y por tanto, el motor se queda funcionando continuamente a pesar de variar el ciclo
de trabajo. Así que se descartó esta opción.
Para intentar conseguir que el motor funcionase se buscaron unos nuevos transistores
que trabajasen a una frecuencia mayor, para ello se buscaron transistores de radiofrecuencia
cuyo orden de trabajo llega a los megahercios.
Ilustración 4.42 Respuesta de la etapa BJT
Ilustración 4.43 Etapa BJT con motor y respuesta de la etapa
MEMORIA 75
Los transistores elegidos para esta nueva prueba fueron: 2N2219A como NPN y
2N2905 como PNP. Los valores de las resistencias se mantuvieron constantes.
Se comprueba como en este caso, a pesar de que los transistores trabajan muy por
debajo de su rango de frecuencia máxima también tienen problemas con el paso de corte a
conducción. En el montaje completo de una rama se vuelve a apreciar claramente el efecto.
Se vuelve a poner de manifiesto como, a pesar de ser los transistores de radio
frecuencia no resultan óptimos para este trabajo.
Ilustración 4.44 Etapa radiofrecuencia y resultado
Ilustración 4.45 Etapa radio frecuencia y resultados
MEMORIA 76
Viendo que no se conseguía de ninguna forma la forma de onda adecuada en el motor
hubo que bajar la frecuencia de trabajo. Se modificó el registro del Arduino para que generase
un PWM de 7.8125 kHz. En la imagen inferior se puede ver la línea de comando modificada.
En un principio terminaba en 0x01, al poner el 0x02 el prescaler se divide entre 8 y se
obtiene el PWM de la frecuencia deseada.
La etapa que se empleó en este caso fue con los transistores de radio frecuencia. El
resultado de la simulación, con un motor conectado, fue el siguiente:
Se puede observar como los ciclos de trabajo están más marcados, aunque solo llegan
en un breve instante de tiempo a cortar completamente la señal.
A pesar de que con todas las pruebas realizadas el resultado no ha sido el esperado se
decidió seguir trabajando sobre el diseño la última etapa. La siguiente modificación que se
realizó fue incorporar un optotransistor para tener aislada el pin del Arduino y que en caso de
que se produjese algún pico de corriente inverso éste quedase protegido y fuese el
optotransistor el que sufriese el daño. El chip elegido fue el CNX82, el parámetro más crítico
para su elección fue la tensión colector-emisor (VCE) capaz de soportar, en la práctica debe
ser mayor a 30 voltios. La configuración utilizada con el transistor se conoce como colector-
Ilustración 4.46 Configuración PWM Arduino
Ilustración 4.47 Resultado etapa 7.8125 kHz
MEMORIA 77
abierto (open.-collector). Además se sustituyó el transistor superior por uno de canal P (P-
MOS).
Los P-MOS se eligen de manera complementaria a los N-MOS, al igual que cuando se
trabaja con transistores BJT y se utilizan NPN y PNP.
A diferencia de los N-MOS, los P-MOS trabajan con tensiones negativas respecto a la
fuente pero la magnitud de sus valores es la misma que la de sus complementarios. En este
caso se empleó un P-MOS IRF9540.
Incorporando este P-MOS su activación resulta mucho más sencilla que la de un N-
MOS pues éste necesita una caída de tensión del orden de 2 a 4 voltios para abrirse. La caída
de tensión se obtiene incorporando una resistencia entre la fuente y la puerta.
Se puede comprobar que la salida para este caso se aproxima bastante a la esperada a
pesar de que se aprecia bastante ruido en la puerta de los MOSFETs. Aún así en este circuito
todavía se presenta un problema. La resistencia R2 se encarga de bajar la tensión necesaria
para que la puerta del MOSFET superior entre en plena conducción pero provoca que el
MOSFET inferior presente 33 voltios entre la puerta y la fuente, lo que supone que disipará
924 watios (33 voltios · 28 amperios) algo que supone una difícil tarea de disipar. Es necesario,
por tanto, tener que rebajar la tensión en la puerta del transistor inferior. Cualquiera de las
soluciones que se presenta a continuación no mostró el resultado esperado, o bien llevaban la
tensión de las puertas a tierra, o la reducían correctamente pero entraban en conflicto con las
capacidades parásitas de la puerta de los MOSFETs y éstos no se descargaban correctamente y
quedaban cerrados todo el periodo haciendo que el motor no deje de girar.
Ilustración 4.48 Etapa optoacoplador y resultado
MEMORIA 78
Ilustración 4.49 Distintas pruebas para la activación del N-MOS
MEMORIA 79
La solución se encontró en la página web de Gary L. Chemelec de Canadá, aunque el
esquema se puede encontrar en numerosos sitios web.
Este circuito tiene una clara diferencia respecto y es que la activación de los N-MOS se
realiza cuando se abren los P-MOS, se podría decir que con este método las puertas de los N-
MOS se abrirían más tarde que las de los P-MOS y la reacción del motor no sería instantánea.
Realizando las pruebas se ha comprobado que ese tiempo es despreciable y no afecta al
funcionamiento del motor.
Al igual que en todos los modelos probados anteriormente, hay que obtener una
tensión adecuada en las puertas para que la potencia disipada sea la menor posible.
Mirando la hoja de datos que nos proporciona el fabricante, son necesarios 100nA
para abrir la puerta del transistor. Como tenemos 5 transistores en paralelo, será necesario que
circulen 500nA. Por lo que obtendremos el siguiente valor de resistencia:
𝑉 = 𝐼 · 𝑅 → 𝑅 =𝑉𝐼 =
36− 320,5𝑚𝐴 = 8𝑘Ω
También es necesario calcular la resistencia del optoacoplador para que pueda circular
esa corriente. Para ello es necesario mirar la gráfica que nos ofrece el fabricante.
Ilustración 4.50 Puente H de Gary L. Chemelee
MEMORIA 80
En nuestro caso debemos mirar primero la gráfica de la derecha, nosotros queremos
que por el colector circulen como mínimo 0,5mA. Ese valor lo tenemos que mirar sobre el eje
Y, lo proyectamos en el eje X y obtenemos un valor entre 4 y 5mA por el LED,
aproximaremos mejor a 5mA para no quedarnos cortos. Trasladándonos ahora a la gráfica de
la derecha, sobre el eje X buscamos 5mA y proyectamos sobre el eje Y. Esto se traduce en que
aplicando una entrada de 1 voltio a la entrada del optoacoplador permitirá circular la corriente
necesaria para abrir las puertas de los P-MOS.
Sabemos que el Arduino en cada salida proporciona 5 voltios y hasta 40mA. Por lo
cual debemos colocar una resistencia adecuada capaz de reducir la tensión de salida del
Arduino a la exigida por el optoacoplador.
𝑅 =𝑉𝐼 =
𝑉!"# − 𝑉!"#𝐼!"#
=5− 15𝑚𝐴 = 800Ω
Como en el mercado no se encuentra ese valor exacto utilizaremos una resistencia con
tolerancia del 1% con valor 787 Ohms. Si hubiésemos seleccionado una de valor superior
estaríamos reduciendo la corriente que pasa por el circuito y podría no ser suficiente para abrir
las puertas.
Para obtener la tensión en las puertas de los N-MOS se implementó un divisor de
tensión.
𝑉!"#$ =𝑅!
𝑅! + 𝑅!· 𝑉!"#$ →
𝑉!"#$𝑉!"!"
=𝑅!
𝑅! + 𝑅!→
336− 1,4 =
𝑅!𝑅! + 𝑅!
→ 0,08 · 𝑅! + 𝑅! = 𝑅! → 0,08 · 𝑅! + 0,08 · 𝑅! = 𝑅!
Ilustración 4.51 Gráficas para la optimización del optoacoplador
MEMORIA 81
→ 0,08 · 𝑅! = 1− 0,08 · 𝑅! → 𝑅! =1− 0,080,08 · 𝑅! → 𝑅! = 11,5 · 𝑅!
Con la relación obtenida, si asignamos a R2 el valor de 1k R1 deberá valer 11,5k
aunque por valores comerciales se cogerá una de 10k.
A continuación se muestra el esquema que se diseñó con estos elementos.
En la gráfica se puede observar de color amarillo la tensión de entrada al
optoacoplador después de la resistencia, de color azul la tensión en la puerta del P-MOS, de
color rojo la tensión de la puerta del N-MOS y de color verde la tensión a la entrada del
motor. Las líneas azules horizontales muestran el valor de la magnitud respecto a tierra.
En la parte de la gráfica que muestra la señal del motor se pueden apreciar importantes picos
de corriente inversa, para compensar este sistema es necesario incorporar unos diodos de libre
circulación.
Ilustración 4.52 Esquema conexión optoacoplador
MEMORIA 82
A continuación se pueden observar una serie de fotos de la placa realizada.
Ilustración 4.53 Resultados Puente H definitivo
MEMORIA 83
Diodos de libre circulación:
Los diodos de libre circulación también pueden ser denominados como diodo
snubber, flyback diode o diodo supresor.
Estos diodos son empleados para eliminar las corrientes inversas. Estas suceden
cuando hay un cambio brusco de tensión en una carga inductiva.
Podemos simplificar el caso que nos afecta a dos estados. En el primero el MOSFET
ha estado cerrando el circuito durante un largo periodo de tiempo y el motor, que es una carga
inductiva, se ha cargado de energía y se comporta como un cortocircuito. La corriente está
desplazándose del terminal positivo del motor al negativo a través de la bobina. Cuando se
deja de alimentar la puerta del MOSFET, ésta se cierra. En ese momento el motor intentará
que ese cambio brusco en la alimentación no se haga efectivo aplicando toda su energía
almacenada al circuito. Esto provoca que se cree un potencial negativo donde antes era
positivo y viceversa en el otro terminal del motor.
Ilustración 4.54 Placa para los optoacopladores
MEMORIA 84
Un diodo de libre circulación soluciona este problema creando una rama paralela que
descarga toda la energía almacenada hasta que ésta se descarga por las pérdidas en el circuito y
la caída en el diodo.
Cuando el circuito se cierra de nuevo, el diodo se polariza en inversa y no afecta al
rendimiento del circuito. Al abrirse de nuevo el circuito, el diodo se polarizará en directa al
motor, permitiendo circular a la corriente almacenada en un loop temporal mientras quede
energía almacenada.
La tensión a través del motor disminuirá en función de la caída en el diodo. El tiempo
de duración de éstas corrientes inversas varía en función del tamaño de la inductancia pero
suele ser del orden de los milisegundos.
Para seleccionar un diodo ideal, el primer punto de referencia es que aguante elevados
picos de corriente (de esta forma podrá aguantar grandes transiciones de voltaje sin quemarse),
el segundo una tensión de polarización mínima y que la tensión caiga toda de nuevo en la
inductancia y el tercer punto sería la corriente de pico inversa capaz de soportar. Dependiendo
del sistema que se esté tratando, en algunas ocasiones las tensiones que se generan pueden ser
del orden de 10 veces de la nominal, por lo que es importante hacer un cálculo elevado del
elemento.
Cuando el sistema funciona con corriente continua, el diodo puede causar un retraso
en el corte de la corriente cuando se abre el circuito. Si la frecuencia del sistema es crucial, se
puede colocar una resistencia con valor muy bajo en serie con la inductancia para ayudar a
disipar la energía de la bobina más rápido.
Ilustración 4.55 Diodo en paralelo con inductancia
MEMORIA 85
Para el proyecto, debido al desconocimiento del vehículo con carga se ha optado por
colocar unos diodos de gran capacidad. El modelo seleccionado ha sido un diodo de potencia
de recuperación estándar, 70HF(R) Series.
Este diodo es capaz de soportar 70 amperios de manera continua y hasta picos de
1200 amperios.
Ilustración 4.56 Diodo en paralelo con resistencia en serie
Ilustración 4.57 Diodo empleado en el proyecto
MEMORIA 86
A continuación se muestran unas imágenes de la colocación de los diodos en el
vehículo.
Ilustración 4.58 Colocación de los diodos de protección
MEMORIA 87
4.7 Protecciones:
A la hora de proteger todo el vehículo de algún cortocircuito que pudiese ocurrir en el
vehículo se han colocado dos tipos de protecciones: un magnetotérmico y tres fusibles.
Un interruptor magnetotérmico, es un dispositivo capaz de interrumpir la corriente
eléctrica de un circuito cuando ésta sobrepasa ciertos valores máximos. Su funcionamiento se
basa en dos de los efectos producidos por la circulación de corriente eléctrica en un circuito: el
magnético y el térmico (efecto Joule). El dispositivo consta, por tanto, de dos partes, un
electroimán y una lámina bimetálica, conectadas en serie y por las que circula la corriente que
va hacia la carga.
Al circular la corriente por el electroimán, crea una fuerza que, mediante un dispositivo
mecánico adecuado, tiende a abrir el contacto, pero sólo podrá abrirlo si la intensidad que
circula por la carga sobrepasa el límite de intervención fijado. Esta parte es la protectora frente
a cortocircuitos.
La otra parte está constituida por una lámina bimetálica que, al calentarse por encima
de un determinado límite, sufre una deformación y pasa a la posición señalada en línea de
trazos lo que, mediante el correspondiente dispositivo mecánico, provoca la apertura del
contacto.
Ilustración 4.59 Interruptor magnetotérmico
MEMORIA 88
Un fusible es un dispositivo, constituido por un filamento o lámina de un metal
o aleación de bajo punto de fusión que se intercala en un punto determinado de una
instalación eléctrica para que se funda, por Efecto Joule, cuando la intensidad de corriente
supere, por un cortocircuito o un exceso de carga, un determinado valor que pudiera hacer
peligrar la integridad de los conductores de la instalación con el consiguiente riesgo de
incendio o destrucción de otros elementos.
Ilustración 4.60 Fusible de car audio empleado
MEMORIA 89
4.8 Conexiones eléctricas y secciones de cable:
Dirección
Control
MOSFETs Magnetotérmico Fusibles
Panel de control
Baterías
Motor Router
Arduino
Opt
oaco
plad
ores
Dirección
MOSFETs
Dire
cció
n
Panel de control
+12
+24
Ilustración 4.61 Conexiones del vehículo
MEMORIA 90
En los esquemas anteriores se pueden observar las conexiones que se realizarán entre
los distintos dispositivos que componen el vehículo.
Para los cálculos de la sección de los cálculos se debe emplear la siguiente fórmula:
𝑆 =2 · 𝐿 · 𝐼 · 𝜌
∆𝑉
Donde:
• S = sección del cable.
• L = Longitud del cable.
• I = Corriente máxima.
• 𝜌 = conductividad del cobre (1/56).
• ∆𝑉 = Caída de tensión (en voltios).
Tensión Elementos Corriente
máxima
Longitud Caída de
tensión
Sección
calculada
Sección
instalada
+12 Arduino 1 A 2 metro 1% = 0,12 0,6mm2
1,5mm2 Router 1 A 2 metro 1% = 0,12 0,6mm2
+24 Dirección 1,5 A 2 metros 1% = 0,24 0,44mm2 1mm2
+36 Motor 30 A 2 metro 1% = 0,36 9mm2 10mm2
Tabla 4.9 Secciones de cable calculadas
Para todas las señales digitales se ha utilizado cable de comunicación, pues está
comprobado que su sección es suficiente en el proyecto.
MEMORIA 91
Ilustración 4.62 Caja de control
Ilustración 4.63 Conexiones de los MOSFETs y el motor
MEMORIA 92
5. DISEÑO DEL SOFTWARE PARA ARDUINO
A continuación se muestran los diagramas de flujo del programa creado en la tarjeta
Arduino para el control y las comunicaciones de todo el proyecto.
5.1 Esquema general:
Al arrancar el Arduino lo primero que realiza es la configuración del mismo, asignar
pines de entrada y salida, configurar el puerto servidor y las comunicaciones.
A continuación entra en el loop principal y está chequeando constantemente el
interruptor de selector de modo para entrar en los distintos modos de conducción.
Inicio Arduino
Configuración
¿Selector de modo?
Local 1 Local 2 Standby Remoto
Volante
Ilustración 5.1 Esquema general
MEMORIA 93
5.2 Local 1:
En el modo de conducción “Local 1” se emplea el acelerador de moto para la tracción,
con el interruptor de selección de marcha se escoge el sentido de ésta y la dirección se realiza
de forma manual.
5.3 Local 2:
El modo de conducción “Local 2” emplea el thumb joystick para controlar tanto la
tracción como la dirección. Lo primero que se realiza es la comprobación del eje Y del joystick
para chequear el sentido de la marcha y la velocidad, a continuación se verifica el estado del eje
X para realizar las operaciones que correspondan en la dirección.
Local 1
¿Selector marcha?
Avance Paro Retroceso
Ilustración 5.2 Modo "Local 1"
MEMORIA 94
Local 2
¿Joystick eje Y?
Avance Paro Retroceso
Volante
¿Joystick eje X?
Izquierda Paro Derecha
Ilustración 5.3 Modo "Local 2"
Ilustración 5.4 Modo "Volante"
MEMORIA 95
5.4 Remoto:
Al activar el modo “Remoto” el Arduino se queda a la espera de que haya un cliente
conectado para recibir datos. Una vez que los ha recibido el primer campo corresponde con el
sentido de giro de la tracción y el segundo con la velocidad. El tercer campo es el valor de la
dirección y el último corresponde a encender o apagar las luces.
Remoto
Recibir datos
¿Tracción?
Avance Paro Retroceso
¿Dirección?
Izquierda Paro Derecha
Enviar datos
Ilustración 5.5 Modo "Remoto"
MEMORIA 96
5.5 Avance:
La función de “Avance” escribe sobre el pin de avance un PWM correspondiente al
valor de la consigna del acelerador. A continuación llama a la función “Letrero”.
5.6 Retroceso:
La función de “Retroceso” escribe sobre el pin de retroceso un PWM correspondiente
al valor de la consigna del acelerador. A continuación llama a la función “Letrero”.
Avance
Salida = Acelerador
Letrero
Retroceso
Salida = Acelerador
Letrero
Ilustración 5.6 Función "Avance"
Ilustración 5.7 Función "Retroceso"
5.7 Paro:
La función de “Paro” pone a 0 el estado de los dos pines de la tracción. A
continuación llama a la función “Letrero”.
5.8 Letrero:
En la función “Letrero” se comprueba el valor de consigna del acelerador para poder
mostrar cada dígito en su correspondiente display.
Paro
Salida = 0
Letrero
Ilustración 5.8 Función "Paro"
MEMORIA 98
Letrero
¿Acelerador?
Unidades
Decenas
Centenas
Ilustración 5.9 Función "Letrero"
MEMORIA 99
6. DISEÑO DEL SOFTWARE PARA EL DISPOSITIVO MÓVIL
6.1 Introducción
Para el desarrollo de la aplicación del dispositivo de control móvil se utilizó el
programa LiveCode Community en su versión 6.0, la cual es gratuita y se puede descargar
en http://livecode.com/download/
LiveCode es un entorno de desarrollo gráfico. Utiliza un lenguaje de programación
orientado a eventos. Además incluye un simulador para poder depurar mejor el código.
La programación orientada a eventos consiste en crear diversos eventos cuya
ejecución va determinada por los sucesos que ocurren en el sistema, definidos por el
usuario o que provoquen ellos mismos.
Cuando se inicializa el programa se llevan a cabo las inicializaciones y demás código
inicial y a continuación el programa quedará bloqueado hasta que se produzca algún
evento. Cuando alguno de los eventos esperados por el programa tenga lugar, el programa
pasará a ejecutar el código correspondiente a esa acción.
En LiveCode no hace falta asignar ningún tipo de variable, basta con nombrarlas y
el programa le asignará el formato más eficiente según el contenido de ésta. La
organización de la memoria es totalmente automática.
Las aplicaciones creadas son multiplaformas, pueden ser creadas para: Mac,
Windows, Linux, iOS y Android.
Los programas en LiveCode tienen una estructura organizada en una baraja
principal y distintas sub-barajas. Cada baraja y sub-baraja puede estar, a su vez, formada
por distintas tarjetas llamadas cartas.
Haciendo una simplificación de este sistema se puede definir la baraja principal
como el conjunto del programa en sí y las cartas como cada una de las distintas pantallas
que se muestran al usuario según las acciones que realice. Del mismo modo, en las sub-
barajas se incluyen las configuraciones o clases para los distintos objetos y cartas que
forman la baraja principal. Por ejemplo si en todas las cartas va a mostrarse un mismo
botón que realiza la misma acción basta crearlo una vez en una sub-baraja y llamarlo en
cada carta.
Debido a lo simple del programa que se ha creado en el proyecto no han hecho
falta crear sub-barajas y consta de la baraja principal y 3 cartas.
MEMORIA 100
A pesar de que LiveCode es un programa muy potente, no todas las funciones que
incorpora están disponible para el desarrollo de aplicaciones móviles. Este problema quedó
patente al tener que modificar todo el diseño del programa por no poder implementar una
comunicación TCP/IP entre el Arduino y el dispositivo móvil.
Por ello se tuvo que realizar la conexión entre ambos elementos mediante el envío y
recepción de peticiones HTTP.
6.2 Comunicación
La comunicación entre el control del coche y el usuario ha sido uno de los puntos
más difíciles de crear en el proyecto pero uno de los puntos fuertes de éste.
Existen numerosos proyectos similares a éste pero cuya conexión se realiza
mediante bluetooth. Si se hubiese escogido esta opción simplemente hubiese bastado con
escoger las librerías oportunas y adaptarlas al proyecto pero se hubiese tenido una gran
restricción y es que los bluetooth incorporados en los móviles solo tienen un alcance de 10
metros.
Por eso se ha optado por colocar un router wifi en el coche con el estándar WiFi G
(802.11b) capaz de ofrecer una conexión de hasta 100 metros.
En la imagen superior se puede observar el esquema de conexión de
comunicaciones del proyecto.
Arduino
Router
Móvil
LAN
Ilustración 6.1 Conexión vía wifi
MEMORIA 101
6.3 Estructura del programa
Como se ha comentado en el punto anterior el programa solo está formado por la
baraja principal y 3 cartas.
Se puede observar en el gráfico anterior que desde la carta “Inicio” se puede
acceder a las otras dos restantes, mientras que desde las otras dos solo se puede volver a la
carta “Inicio”. Esto es porque la estructura elegida para el programa consiste en una
pantalla principal que da la opción de poder entrar en cada una de las dos cartas.
6.3.1 Carta Inicio:
Baraja
Carta 1:
Inicio
Carta 2:
Configuración
Carta 3:
Conducción
Ilustración 6.2 Estructura del programa
Ilustración 6.3 Carta "Inicio"
MEMORIA 102
Se pueden apreciar los dos botones que nos llevan a las otras dos cartas. Además
hay un campo en la esquina superior derecha que indica la URL que tiene asignada el
programa para conectarse con el Arduino.
También se incluye una configuración inicial cuando se inicia el programa que
asigna la siguiente URL por defecto: http://192.168.1.2:1025. Se ha incluido también un
aviso que salta al iniciar al programa que comunica la dirección predefinida por si el usuario
la desconoce o necesita cambiarla.
6.3.2 Carta Configuración:
La carta “Configuración” es la más sencilla de todas. En ella solo se muestra dos
campos para rellenar correspondientes a la dirección URL de conexión.
Si los dos campos no son rellenados no se podrá volver a la carta “Inicio” saltando
un aviso que lo indique. Por el contrario, si se han rellenado los dos campos al presionar el
botón “Volver” muestra la URL ingresada y regresa a la carta anterior.
Ilustración 6.4 Carta "Configuración"
MEMORIA 103
6.3.3 Carta Conducción:
Ilustración 6.5 Carta "Conducción"
La carta “Conducción” es la más compleja de todas. Está compuesta por diferentes
elementos de información y actuación.
A continuación se muestra un esquema simplificado de la carta.
Información
URL Conectada LED
Acelerador Dirección Marcha
Luces
Menú
Ilustración 6.6 Carta "Conducción"
MEMORIA 104
Los iconos de color rojo muestran iconos que generan eventos en el programa
mientras que los de color azul ofrecen información sobre el estado del coche.
Cuando entramos en la carta, hasta que no se presiona el botón “acelerador” o
“dirección” no se empieza a realizar una conexión entre el móvil y el Arduino. En ese
momento se genera otro evento “oculto” (background) que va contando el tiempo que
transcurre mientras se realiza la conexión, si ese tiempo supera los 40 milisegundos el
indicador “LED” cambia a color amarillo indicando que la conexión está tardando más de
lo normal. Y si la conexión falla se pone de color rojo.
La imagen que se muestra del avión se hace necesaria para entender como se
maneja el vehículo desde el móvil. Los tres ejes que se muestran en la imagen corresponden
con las medidas que obtiene el giróscopo del móvil cuando movemos éste.
Al coger el móvil de forma horizontal como obliga la aplicación la aceleración del
vehículo se realiza girando éste a través del eje Y que equivale al Pitch Axis del avión y la
dirección se realiza girando sobre el eje X, Roll Axis.
Ilustración 6.7 Acelerómetros del móvil
MEMORIA 105
Cuando se activa uno de los dos iconos, para acelerar o girar, se activa el giróscopo
del móvil y lee los datos del sensor comparándolos con los que tenía guardados
anteriormente. Estos datos se envían al Arduino mediante URL.
Durante el desarrollo del programa se intentó que el vehículo se moviese hacia
delante o hacia atrás según la posición del móvil que sería un control mucho más intuitivo
del vehículo pero al inicializar el giróscopo de nuevo se generaba un cambio de variable en
el sentido opuesto de giro que inmediatamente se revertía indicando al Arduino el sentido
de avance correcto. Debido a este problema y con la intención de que los Mosfets que
controlan el motor no sufriesen en exceso se colocaron en la pantalla los botones de
“Avance”, “Paro” y “Retroceso”. De esta forma se obliga al vehículo a ir en el sentido
seleccionado o a pararse. Además para evitar confusiones el sentido de giro seleccionado se
queda oculto para que el usuario sepa que solo puede seleccionar las otras dos opciones y
de este modo conozca el sentido del coche y no repita una orden.
Ilustración 6.8 Modo "Avance" activado
En la imagen superior se puede observar como ha desaparecido la opción de “Avance”
porque es la que está activa en ese momento.
MEMORIA 106
7. CONCLUSIONES Y RESULTADO:
Inicio este capítulo con una breve valoración personal ya que a lo largo de todas las
etapas del desarrollo del proyecto se han obtenido una serie de aprendizajes que quiero que
queden recogidas en este documento. La mayoría de las mismas son apreciaciones
obtenidas del trabajo diario en el laboratorio y de la resolución de los problemas que allí
surgieron.
La primera de todas sin duda es que se necesita bastante tiempo para
estudiar, comprender y entender los diversos componentes que se necesitan para llevar a
cabo un proyecto desde cero. No solo la parte electrónica que es la que más se ha
desarrollado en este proyecto. Al terminarlo te das cuenta de todas las mejoras que se
pueden realizar, que es preferible dedicar más tiempo a los estudios previos y realización de
pequeñas maquetas que puedan ayudar a identificar problemas en lugar de creer en una
idea inicial y desarrollarla sin analizar sus puntos fuertes y débiles.
Del mismo modo, se hacea necesario comentar la cruda realidad en el mundo de la
electrónica. Te puedes pasar varios días diseñando un circuito electrónico, calculando sus
componentes, comprobando que los cálculos son correctos, realizando simulaciones en el
ordenador y corrigiendo los fallos que se detectan. Pero, a pesar de todo ese desarrollo
previo, es difícil que el circuito funcione correctamente en el primer montaje. Y es
necesario buscar soluciones alternativas y nuevos componentes para lograr que el circuito
funcione como se desea. Debido al elevado número de veces que ha sido necesario buscar
soluciones, esto ha provocado un incremento de conocimientos constantes. Si los circuitos
hubiesen funcionado a la primera, o se hubiesen comprado ya funcionando, no se hubiesen
aprendido los problemas que tienen las aplicaciones de conmutación según la frecuencia de
trabajo, o porque es más fácil utilizar un dispositivo controlado por tensión que por
corriente o los sistemas de protección que se pueden incorporar como los
optoacopladores.
También ha resultado muy interesante aprender el lenguaje de programación que
actualmente se está utilizando para crear aplicaciones móviles multiplataformas y que te
obliga a aprender a pensar de una nueva manera. Ya la programación no se realiza de un
modo lineal, se escriben los eventos que son necesarios para que todo el programa se
ejecute y, a continuación todos estos se relacionan mediante llamadas y pueden estar
ejecutándose de trasfondo, en primer plano o estar latentes hasta que son llamados.
MEMORIA 107
Además de que existen distintas capas en el programa y se puede estar en una única capa
con sus eventos o, por el contrario, estar en varias capas simultáneamente.
Otra valoración que considero importante, no solo es necesario dominar un campo
para la realización de un proyecto, se ha puesto de manifiesto en el resultado final del
proyecto el desconocimiento en conceptos de mecánica y materiales. Todo el rendimiento
del proyecto se ha visto mermado por el mal cálculo y diseño de la estructura. No solo por
el desconocimiento de materiales y métodos de cálculo, si no también por no saber enfocar
el diseño a una solución eficaz.
Para concluir este apartado, se hace necesario el poder expresar la gran satisfacción
de poder haber realizado este proyecto pero ésta es, aún mayor, cuando se puede realizar
un repaso a todo el proceso y comprobar todas las experiencias y conocimientos
adquiridos.
Como se ha escrito en la memoria, el proceso de construcción ha resultado bastante
duro y con bastantes contratiempos que han producido tener que modificar el diseño y
tener que reducir las expectativas finales.
Ha sido un pequeño fracaso el no haber conseguido que el sistema trabajase a una
frecuencia mayor, a pesar de las alternativas probadas. O el no poder usar un gate-driver
para el control de los MOSFET.
A pesar de no estar contento con el diseño de la estructura del coche, esta servirá
para que en el próximo diseño se tengan en cuenta todos sus puntos débiles o los
elementos que no son prácticos para poder mejorarlo.
Ha sido interesante poder descubrir una plataforma capaz de desarrollar
aplicaciones para diferentes plataformas con un mismo código. Lo cual simplifica mucho el
proceso y no hace necesario aprender los lenguajes específicos de cada plataforma.
MEMORIA 108
8. BIBLIOGRAFÍA:
• Albert Malvino y David J. Bates, "Principios de Electrónica. 7ª edición", Mc
GrawHill, 2007.
• Bogdan Grabowski, “Prontuario de Electrónica”, Paraninfo Thomson Learning,
1999
• Michael Margolis, “Arduino Cookbook, 1ª edición”, O’Reilly, 2011.
• Jean François Machut, “Selección de componentes de electrónica, 2ª edición”,
Marcombo, 2007.
• http://www.arduino.cc
• http://www.neoteo.com
• http://www.forosdeelectronica.com
• http://www.livecode.com
• http://bricogeek.com
• http://www.wikipedia.org
• chemelec.com
Parte II
Pliego de condiciones y presupuesto
ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA
CIVIL E INDUSTRIAL
Proyecto Fin de Carrera
DESARROLLO DE UN VEHÍCULO ELÉCTRICO DE
CONTROL MANUAL Y REMOTO.
TOMO II
Pliego de condiciones y presupuesto
Titulación: Ingeniería Técnica Industrial. Especialidad Electrónica Industrial
Alumno: Jorge De León Rivas
Tutor: D. Jesús Miguel Torres Jorge
28 de Junio de 2013
9. PLIEGO DE CONDICIONES:
En este capítulo se recoge el conjunto de normas y acciones que se deberán llevar a cabo
en la realización del proyecto.
Los trabajos de elaboración de la electrónica y programación del proyecto se llevarán a
cabo en el laboratorio, en donde se dispondrá de todo el material y equipos necesarios para la
realización del mismo.
Se utilizarán herramientas de software y hardware libre para la realización del proyecto y
la posterior utilización del dispositivo, siempre que exista posibilidad.
El código del programa servidor irá instalado en la memoria del controlador maestro,
aunque éste será adjuntado junto con el código de la aplicación móvil que si habrá de ser alojado
por el usuario en su dispositivo cliente.
Se adjuntarán todos los códigos de los programas realizados y esquemas de PCBs que se
distribuirán con el dispositivo.
10. PRESUPUESTO:
Se presupuestan en este apartado todos los componentes electrónicos, eléctricos y elementos
necesarios para la reproducción del proyecto con excepción del dispositivo móvil. Las horas
de trabajo son calculadas en función de los créditos de la asignatura.
Concepto Precio Ud. Cantidad Subtotal Parte mecánica
Hora de trabajo 20,00 € 10 200,00 € Material vario 60,00 € 1 60,00 € Cadena 10,00 € 1 10,00 € Sillón 12,00 € 1 12,00 € Estructura sillón 8,00 € 1 8,00 € Tornillo 912 Allen 10x40 0,57 € 10 5,70 € Arandela INOX plana 10 0,08 € 20 1,60 € Tuerca seguridad M10 0,18 € 10 1,80 € Tuerca hexagonal M8 0,07 € 10 0,70 € Tuerca seguridad M8 0,10 € 6 0,60 € Tornillo 912 Allen 8x40 0,39 € 2 0,78 € Tornillo 912 Allen 8x50 0,45 € 2 0,90 € Tornillo 912 Allen 8x30 0,28 € 2 0,56 € Tornillo 10x2 2,00 € 1 2,00 € Tornillo 16x3 2,00 € 1 2,00 € Arandela seguridad 2mm 2,00 € 1 2,00 € Arandela 3mm 2,00 € 1 2,00 €
Total 310,64 €
Parte eléctrica Magnetotérmico tetrapolar 30,80 € 1 30,80 € Portafusible car-‐audio 4,28 € 1 4,28 € Portafusible aereo 0,51 € 2 1,02 € Fusible car-‐audio 40A 0,70 € 1 0,70 € Fusible 5A 0,20 € 2 0,40 € Amperímetro panel 30ADC 19,90 € 1 19,90 € Amperímetro panel 5ADC 9,90 € 2 19,80 € Voltímetro panel 50VDC 3,07 € 1 3,07 € Voltímetro panel 36VDC 3,07 € 1 3,07 € Voltímetro panel 15VDC 3,07 € 1 3,07 € Cable 10mm2 1,82 € 8 14,56 € Cable 1,5mm2 0,25 € 20 4,90 €
Cable 2x0,75mm2 0,61 € 8 4,88 € Cable manguera 6 hilos 0,71 € 4 2,84 € Cable manguera 10 hilos 0,91 € 2 1,82 € Cable manguera 8 hilos 0,81 € 2 1,62 € Terminal redondo 0,75mm2 0,18 € 4 0,72 € Terminal redondo 1,5mm2 0,20 € 4 0,80 € Terminal redondo 8mm2 0,30 € 2 0,60 € Puntera 0,75mm2 0,19 € 20 3,80 € Puntera 1,5mm2 0,25 € 10 2,50 € Puntera 3mm2 0,30 € 10 3,00 € Puntera 10mm2 0,60 € 20 12,00 € Funda termorretractil 0,75mm2 0,49 € 2 0,98 € Funda termorretractil 2mm2 0,75 € 2 1,50 € Funda termorretractil 4mm2 0,80 € 2 1,60 € Motor 800W 30A 92,00 € 1 92,00 € Actuador lineal 83,00 € 1 83,00 € Acelerador de moto 9,99 € 1 9,99 € Thumb joystick 3,10 € 1 3,10 € Arduino MEGA 56,00 € 1 56,00 € Ethernet Shield 28,50 € 1 28,50 € Router 2ª mano 10,00 € 1 10,00 € Batería 15Ah 30,00 € 3 90,00 € MOSFET IRFZ44N 1,28 € 10 12,80 € MOSFET IRF9540 1,50 € 10 15,00 € Optoacoplador CNX82 0,96 € 2 1,92 € Resistencias THD varias 0,03 € 6 0,18 € Resistencias SMD varias 0,03 € 10 0,30 € LEDs 3mm 0,17 € 2 0,34 € Baquelita 100x150 6,50 € 1 6,50 € Conector 4 pines 3,40 € 1 3,40 € Conector 8 pines 4,60 € 1 4,60 €
Total 561,86 €
Otros Diseño, estudio y montaje 8,00 € 75 600,00 €
Total 600,00 €
Total acumulado 1.472,50 €
Parte III
Anexos
ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA CIVIL
E INDUSTRIAL
Proyecto Fin de Carrera
DESARROLLO DE UN VEHÍCULO ELÉCTRICO DE
CONTROL MANUAL Y REMOTO.
TOMO III
ANEXOS
Titulación: Ingeniería Técnica Industrial. Especialidad Electrónica Industrial
Alumno: Jorge De León Rivas
Tutor: D. Jesús Miguel Torres Jorge
28 de Junio de 2013
ANEXO A
ESQUEMAS Y PCB
Figura A.1 Esquema panel de control THD
Figura A.2 PCB panel de control THD cara superior
Figura A.3 PCB panel de control THD cara inferior
Figura A.4 Esquema panel de control SMD
Figura A.5 PCB panel de control SMD cara superior
Figura A.6 PCB panel de control SMD cara inferior
Figura A.7 Esquema para la PCB de interruptores
Figura A.8 PCB para los interruptores cara inferior
Figura A.9 PCB para los interruptores cara inferior
Figura A.10 Esquema para los LEDs SMD
Figura A.11 PCB para los LEDs SMD
Figura A.12 Esquema para los displays en SMD
Figura A.13 PCB para los displays en SMD cara superior
Figura A.14 PCB para los displays en SMD cara inferior
Ilustración A.1 Esquema panel de control THD
Ilustración A.2 PCB panel de control THD cara superior
Ilustración A.3 PCB panel de control THD cara inferior
Ilustración A.4 Esquema panel de control SMD
Ilustración A.5 PCB panel de control SMD cara superior
Ilustración A.6 PCB panel de control SMD cara inferior
Ilustración A.7 Esquema para la PCB de interruptores
Ilustración A.8 PCB para los interruptores cara inferior
Ilustración A.9 PCB para los interruptores cara inferior
Ilustración A.10 Esquema para los LEDs SMD
Ilustración A.11 PCB para los LEDs SMD
Ilustración A.12 Esquema para los displays en SMD
Ilustración A.13 PCB para los displays en SMD cara superior
Ilustración A.14 PCB para los displays en SMD cara inferior
ANEXO B
Códigos fuente
B.1 Código Arduino
B.2 Código LiveCode Carta Inicio
B.3 Código LiveCode botón “modo”
B.4 Código LiveCode botón “configuracion”
B.5 Código LiveCode botón “volver”
B.6 Código LiveCode botón “pulgar”
B.7 Código LiveCode botón “giro”
B.8 Código LiveCode botón “retroceso”
B.9 Código LiveCode botón “paro”
B.10 Código LiveCode botón “avance”
B.11 Código LiveCode botón “volver”
B.12 Código LiveCode carta “conducción”
B1. Código Arduino /* Programa para el control de un vehiculo remoto */
/* Jorge De Leon Rivas */
/* PFC ITI-Electronica Industrial Curso 2012-2013 */
/* LIBRERIAS */
#include <SPI.h>
#include <Ethernet.h>
String mensaje;
String line;
/* ENTRADAS ANALOGICAS */
int SELECTOR = A0; //Selector para el modo (LOCAL1, LOCAL2, STANDBY o REMOTO)
int ACELERADOR_M = A2; //Acelerador del manillar
int SENTIDO = A1; //Selector AVANCE/RETROCESO
int JOYSTICK_TRAC = A3; //Aceleracion del vehiculo con el joystick (retroceso/paro/avance)
int JOYSTICK_DIRE = A4; //Direccion del vehiculo con el joystick (izquierda/paro/derecha)
/* SALIDAS DIGITALES */
int MOTOR_RETR = 7; //Pin PWM para el retroceso del motor
int MOTOR_AV = 13; //Pin PWM para el avance del motor
int GIRO_IZQUIERDA = 14; //Pin para el giro hacia la izquierda de la direccion
int GIRO_DERECHA = 15; //Pin para el giro hacia la derecha de la direccion
int LED_AVANCE = 36; //Led indicador avance motor
int LED_PARO = 37; //Led indicador "punto muerto"
int LED_RETROCESO = 35; //Led indicador retroceso motor
int LED_IZQ = 32; //Led indicador del giro hacia la izquierda
int LED_IZQ_TOP = 33; //Led indicador que la dirección está girada al máximo a la izquierda
int LED_DCHA = 34; //Led indicador del giro hacia la derecha
int LED_DCHA_TOP = 38; //Led indicador que la dirección está girada al máximo a la derecha
int LUCES = 39; //Pin para las luces del vehiculo
/* ENTRADAS DIGITALES */
int LUCES_PULSADOR = 2; //Pulsador para ACTIVAR/DESACTIVAR las luces
int GIRO_IZQUIERDA_TOPE= 19; //Interruptor FDC que indica que la dirección ha llegado al tope izquierdo
int GIRO_DERECHA_TOPE = 18; //Interruptor FDC que indica que la dirección ha llegado al tope derecho
/* VARIABLES GLOBALES */
int ACELERADOR_M_POS = 0; //Variable que nos indica la posición del acelerador del manillar.
int SELECTOR_POS = 0; //Variable que nos indica la posicion del selector de modo (L1, L2, STBY, RMT). Es global para letrero() ver de que entrada lee.
int JOYSTICK_TRAC_POS = 0; //Variable que nos indica la posicion del joystick de traccion
/* VARIABLES VIRTUALES */
int TRACCION_VIRTUAL = 0; //Variable que nos indica la posicion del acelerador virtual de avance
int DIRECCION_VIRTUAL = 0; //Variable que nos indica el giro a la izquierda virtual
int LUCES_VIRTUAL = 0;
/* VARIABLES DISPLAYS */
int U1 = 42;
int U2 = 43;
int U3 = 44;
int U4 = 45;
int D1 = 46;
int D2 = 47;
int D3 = 48;
int D4 = 49;
int C1 = 50;
int C2 = 51;
int C3 = 52;
int C4 = 53;
const int NUMEROS [] [4]= { //Array de arrays para obtener la combinacion de los 4 pines de los displays
{HIGH}, {HIGH}, {HIGH}, {HIGH}, //0
{HIGH}, {HIGH}, {HIGH}, {LOW}, //1
{HIGH}, {HIGH}, {LOW}, {HIGH}, //2
{HIGH}, {HIGH}, {LOW}, {LOW}, //3
{HIGH}, {LOW}, {HIGH}, {HIGH}, //4
{HIGH}, {LOW}, {HIGH}, {LOW}, //5
{HIGH}, {LOW}, {LOW}, {HIGH}, //6
{HIGH}, {LOW}, {LOW}, {LOW}, //7
{LOW}, {HIGH}, {HIGH}, {HIGH}, //8
{LOW}, {HIGH}, {HIGH}, {LOW} //9
};
/* VARIABLES CONEXIONES ETHERNET */
String recibido; //String para los caracteres enviados por el cliente
byte mac[] = {0xDE,0xAD,0xBE,0xEF,0xFE,0xED}; //Direccion MAC del Arduino
IPAddress ip(192, 168, 1, 2); //Direccion IP del Arduino
EthernetClient client; //Declaramos la variable para identificar al cliente
EthernetServer server(80); //Abrimos el puerto para las comunicaciones
/* RUTINA DISPLAYS (LETRERO) */
//La rutina de los displays se encarga de leer la varible del acelerador que corresponda y mostrar su posición en los 3 displays 7 segmentos
void letrero () {
int acelerador = 0; //Declaramos una variable que llamamos acelerador
if (SELECTOR_POS == 0) //Si estamos en el modo L1 que lea la posicion del acelerador del manillar
acelerador = (ACELERADOR_M_POS); //Multiplicamos por 4 para tener el valor de 0 a 1023
// else
// Aqui tiene que leer la condicion para el modo L2 que lea la posicion del acelerador
int valor = map (acelerador, 0, 1023, 0, 100);
int unidades = valor % 10; //Valor de las unidades
int decenas = valor / 10; //Valor de las decenas
int centenas = valor / 100; //Valor de las centenas
digitalWrite (U1, NUMEROS [unidades][0]); //Salida por el display de unidades
digitalWrite (U2, NUMEROS [unidades][1]);
digitalWrite (U3, NUMEROS [unidades][2]);
digitalWrite (U4, NUMEROS [unidades][3]);
digitalWrite (D1, NUMEROS [decenas][0]);
digitalWrite (D2, NUMEROS [decenas][1]);
digitalWrite (D3, NUMEROS [decenas][2]);
digitalWrite (D4, NUMEROS [decenas][3]);
digitalWrite (C1, NUMEROS [centenas][0]);
digitalWrite (C2, NUMEROS [centenas][1]);
digitalWrite (C3, NUMEROS [centenas][2]);
digitalWrite (C4, NUMEROS [centenas][3]);
}
/* MODOS MOTOR */
//En los modos de motor se realizan las acciones que correspondan según el modo en el que se esté para aplicar el pwm y la dirección indicada al motor.
void avance(){
//Estamos en el modo en que el motor avanza
//Serial.println("Estoy avanzando");
int acelerador = 0; //Creamos una variable interna para el valor de PWM.
if (SELECTOR_POS == 3){ //Depende del modo en el que estemos tendremos que leer un acelerador u otro.
acelerador = analogRead (ACELERADOR_M); //Aquí leemos el acelerador del manillar
// Serial.println(ACELERADOR_M);
acelerador = map (acelerador, 191, 865, 0, 255);
// acelerador = map (acelerador, 47, 215, 0, 255);
Serial.println (ACELERADOR_M);
}
else if (SELECTOR_POS == 0){ //Aquí leemos el joystick y mapeamos su valor
acelerador = analogRead (JOYSTICK_TRAC);
acelerador = map (acelerador, 537, 1023, 0, 255);
}
else if (SELECTOR_POS == 2){
acelerador = TRACCION_VIRTUAL/8
;
// acelerador = map (acelerador, 537, 1023, 0, 255);
}
// Serial.println(acelerador);
digitalWrite (MOTOR_RETR, LOW); //Primero ponemos a baja la otra salida del motor para que no haya ningún corto.
analogWrite (MOTOR_AV, acelerador); //Por el pin correspondiente aplicamos el PWM al motor
digitalWrite (LED_RETROCESO, LOW); //Apagamos el led de retroceso
digitalWrite (LED_PARO, LOW); //Apagamos el led de parada
digitalWrite (LED_AVANCE, HIGH); //Encendemos el led de avance
letrero(); //Vamos a la rutina de letrero().
}
void paro(){
//Estamos en el modo que no se aplica ninguna tensión al motor.
//Serial.println("Estoy en modo paro");
digitalWrite (MOTOR_RETR, LOW); //Ponemos las dos salidas del motor a baja
digitalWrite (MOTOR_AV, LOW);
digitalWrite (LED_RETROCESO, LOW); //Apagamos el led de retroceso
digitalWrite (LED_AVANCE, LOW); //Apagamos el led de avance
digitalWrite (LED_PARO, HIGH); //Encendemos el led de parada
letrero(); //Vamos a la rutina de letrero().
}
void retroceso(){
//Estamos en el modo en que el motor retrocede.
//Serial.println("Estoy retrocediendo");
int acelerador; //Creamos una variable interna para el valor de PWM
if (SELECTOR_POS == 3){ //Depende del modo en el que estemos tendremos que leer un sensor u otro
acelerador = analogRead (ACELERADOR_M); //Aquí leemos el acelerador del manillar
acelerador = map (acelerador, 191, 865, 0, 255);
Serial.println (acelerador);
}
if (SELECTOR_POS == 0){ //Aquí leemos el acelerador del joystick y mapeamos su valor
acelerador = analogRead (JOYSTICK_TRAC);
acelerador = map (acelerador, 487, 0, 0, 255);
}
if (SELECTOR_POS == 2){
acelerador = TRACCION_VIRTUAL/8;
// acelerador = map (acelerador, 487, 0, 0, 255);
}
digitalWrite (MOTOR_AV, LOW); //Primero ponemos a baja la otra salida del motor para que no haya ningún corto
analogWrite (MOTOR_RETR, acelerador); //Por el pin correspondiente aplicamos el PWM al motor
digitalWrite (LED_PARO, LOW); //Apagamos el led de parada
digitalWrite (LED_AVANCE, LOW); //Apagamos el led de avance
digitalWrite (LED_RETROCESO, HIGH); //Encendemos el led de retroceso
letrero(); //Vamos a la rutina de letrero().
}
/* MODO LOCAL1 */
//En el modo local 1 tenemos un interruptor de 3 posiciones que nos indica el sentido del giro del motor: avance-paro-retroceso.
void local1(){
//Serial.println("Estoy en local1");
ACELERADOR_M_POS = analogRead (ACELERADOR_M); //Leemos la posicion del acelerador y la establecemos entre 0-255 (el valor analógico es de 1024 valores y el de pwm de 256)
ACELERADOR_M_POS = ACELERADOR_M_POS/4;
int sentido_pos = analogRead (SENTIDO); //Leemos el selector de avance-paro-retroceso
// Serial.println(sentido_pos);
sentido_pos = map (sentido_pos, 0, 1000, 0, 2); //Mapeamos el valor para asignarlo a nuestras 3 opciones
switch (sentido_pos){
//En el caso de que tengamos un 0 iremos a avance(), con un 1 iremos a paro() y con un 2 iremos a retroceso().
case 0:
retroceso();
break;
case 1:
paro();
break;
case 2:
avance();
break;
}
}
/* MODO LOCAL2 */
//En el modo local 2 todo el coche se maneja desde el joystick, tanto el avance y el retroceso como la dirección. Pero en esta rutina solo nos fijamos en la tracción del coche
void local2(){
//Serial.println ("Estoy en local2");
JOYSTICK_TRAC_POS = analogRead (JOYSTICK_TRAC); //Miramos la posicion del eje X del joystick
//Serial.println (JOYSTICK_TRAC_POS);
if (JOYSTICK_TRAC_POS < 487) //Si el valor que leemos del joystick es menor que 500, quiere decir que tenemos el joystick bajado y vamos a retroceso()
retroceso();
else if (JOYSTICK_TRAC_POS > 537) //Si el valor que leemos del joystick es mayor que 525, quiere decir que tenemos el joystick subido y vamos a avance()
avance();
else //De lo contrario, si el joystick se encuentra entre 500 y 525, no estamos tocando el joystick y vamos a paro()
paro();
}
/* MODO STANDBY */
//En el modo standby, como no se puede introducir una interrupción mediante una entrada analógica, activamos un transistor que si active una entrada digital y ponemos el Arduino en modo sleep.
void standby(){
//Serial.println("Estoy en stanby");
}
/* MODO REMOTO */
//En el modo remoto se realiza una conexión del arduino via ethernet con un router wifi para que se pueda controlar desde un dispositivo con Android
void remoto(){
int sentido;
int acelerador; //Esta variable nos da el mapeo y nos da el valor para enviar al movil
if (!client || !client.connected()){
//Serial.println("Aqui");
acelerador = 0;
client.stop();
client = server.available();
}
if (client) {
// an http request ends with a blank line
line = String();
boolean current_line_is_blank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
line += c;
// if we've gotten to the end of the line (received a newline
// character) and the line is blank, the http request has ended,
// so we can send a reply
if (c == '\n' && current_line_is_blank) {
// send a standard http response header
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/plain");
// print all the files, use a helper to keep it clean
//ListFiles(client, 0);
acelerador = map (TRACCION_VIRTUAL, 0, 2046, 0, 100);
if (sentido == 1){ //Si el valor que leemos del joystick es menor que 500, quiere decir que tenemos el joystick bajado y vamos a retroceso()
mensaje += "AVANCE ";
}
else if (sentido == 2){ //Si el valor que leemos del joystick es mayor que 525, quiere decir que tenemos el joystick subido y vamos a avance()
mensaje += "RETROCESO ";
}
else{
mensaje += "PARO ";
}
mensaje += acelerador;
mensaje += " ";
if (DIRECCION_VIRTUAL > 700){ //Si el valor que leemos del joystick es menor que 500, quiere decir que tenemos el joystick bajado y vamos a retroceso()
mensaje += "DERECHA ";
}
else if (DIRECCION_VIRTUAL < 300){ //Si el valor que leemos del joystick es mayor que 525, quiere decir que tenemos el joystick subido y vamos a avance()
mensaje += "IZQUIERDA ";
}
else{
mensaje += "RECTO ";
}
client.print("Content-Length: ");
client.println(mensaje.length());
client.println();
client.print(mensaje);
Serial.println(mensaje);
//ListFiles(client, 0);
// client.stop();
mensaje = String();
break;
}
if (c == '\n') {
if (line.startsWith("GET")) {
int beginIdx = line.indexOf('?');
if (beginIdx != -1) {
int id1 = line.indexOf(',', ++beginIdx);
sentido = line.substring(beginIdx, id1).toInt();
// TRACCION_VIRTUAL = line.substring(beginIdx, idx).toInt();
// TRACCION_VIRTUAL = TRACCION_VIRTUAL/2; //Se divide entre 2 porque el valor que entrega el movil es entre 0 y 2046 para tener mas resolucion
beginIdx = id1 + 1;
int id2 = line.indexOf(',', beginIdx);
TRACCION_VIRTUAL = line.substring(beginIdx, id2).toInt();
// TRACCION_VIRTUAL = TRACCION_VIRTUAL/2; //Se divide entre 2 porque el valor que entrega el movil es entre 0 y 2046 para tener mas resolucion
beginIdx = id2 + 1;
int id3 = line.indexOf(',', beginIdx);
DIRECCION_VIRTUAL = line.substring(beginIdx, id3).toInt();
// DIRECCION_VIRTUAL = DIRECCION_VIRTUAL / 2;
beginIdx = id3 + 1;
int luces = line.substring(beginIdx).toInt();
Serial.println(sentido);
Serial.println(TRACCION_VIRTUAL);
Serial.println(DIRECCION_VIRTUAL);
Serial.println(luces);
}
/* Seleccion del sentido */ //No se si crear uno comun para todos e invocarlo desde todos los sitios o crear uno en cada funcion
if (sentido == 0) //Si el valor que leemos del joystick es menor que 500, quiere decir que tenemos el joystick bajado y vamos a retroceso()
paro();
else if (sentido == 1) //Si el valor que leemos del joystick es mayor que 525, quiere decir que tenemos el joystick subido y vamos a avance()
avance();
else{
retroceso();
}
direccionvirtual();
}
// we're starting a new line
Serial.println(line);
line = String();
current_line_is_blank = true;
} else if (c != '\r') {
// we've gotten a character on the current line
current_line_is_blank = false;
}
}
}
// give the web browser time to receive the data
//delay(1);
}
}
/* RUTINA PARA ENCENDER LAS LUCES */
//Tenemos un interruptor en los mandos que actúa en forma de interrupción externa para apagar o encender las luces.
//Es la interrupción externa 2 y se sitúa en el pin 21.
void luces(){
// Serial.println("LUCES");
// boolean luces;
// if (SELECTOR_POS == 1 || SELECTOR_POS == 0)
// luces = LUCES_PULSADOR;
if (SELECTOR_POS == 2){
if (LUCES_VIRTUAL == 1){
// Serial.println ("Luces virtuales");
digitalWrite(LUCES, HIGH);
}
else{
// Serial.println ("Luces virtuales");
digitalWrite(LUCES, LOW);
}
// else
// digitalWrite(LUCES, LOW);
}
if (SELECTOR_POS == 3 || SELECTOR_POS == 0){
digitalWrite(LUCES, !digitalRead(LUCES));
}
}
/* DIRECCION VIRTUAL */
void direccionvirtual(){
if (DIRECCION_VIRTUAL < 300 && digitalRead (GIRO_IZQUIERDA_TOPE) != HIGH ) {
digitalWrite (GIRO_DERECHA, LOW); //Apagamos el led de giro a la derecha
digitalWrite (GIRO_IZQUIERDA, HIGH); //Encendemos el led de giro a la izquierda
digitalWrite (LED_DCHA, LOW); //Ponemos a baja la salida del giro a la derecha
digitalWrite (LED_IZQ, HIGH); //Ponemos a alta la salida del giro a la izquierda
digitalWrite (LED_DCHA_TOP, LOW); //Apagamos el led de dirección girada al máximo a la derecha
//Serial.println ("giroizquierda");
}
else if (DIRECCION_VIRTUAL > 700 && digitalRead (GIRO_DERECHA_TOPE) != HIGH) { //Si por el contrario tenemos el joystick girado a la derecha y no está activo su FDC entramos en el bucle
digitalWrite (GIRO_IZQUIERDA, LOW); //Apagamos el led de giro a la izquierda
digitalWrite (GIRO_DERECHA, HIGH); //Encendemos el led de giro a la derecha
digitalWrite (LED_IZQ, LOW); //Ponemos a baja la salida del giro a la izquierda
digitalWrite (LED_DCHA, HIGH); //Ponemos a alta la salida del giro a la derecha
digitalWrite (LED_IZQ_TOP, LOW); //Apagamos el led de dirección girada al máximo a la izquierda
//Serial.println ("giroderecha");
}
else { //En cualquier otro caso, siginifica que no estamos moviendo el joystick sobre el eje X
digitalWrite (GIRO_IZQUIERDA, LOW); //Ponemos a baja la salida del giro a la izquierda
digitalWrite (GIRO_DERECHA, LOW); //Ponemos a baja la salida del giro a la derecha
digitalWrite (LED_DCHA, LOW); //Ponemos a baja el led de giro a la derecha
digitalWrite (LED_IZQ, LOW); //Ponemos a baja el led de giro a la izquierda
//Serial.println ("paro");
//Serial.println (posgiro1);
}
}
/* RUTINA PARA LA DIRECCIÓN */
//En la rutina de dirección el Arduino se encarga de controlar el actuador lineal junto con dos interruptores FDC para mover la dirección
void volante () {
int posgiro1 = 0;
if (SELECTOR_POS == 0)
posgiro1 = analogRead (JOYSTICK_DIRE); //Creamos una variable interna para leer el valor del eje X del joystick
// if (SELECTOR_POS == 2)
// posgiro1 = DIRECCION_VIRTUAL;
int tope_izq = digitalRead (GIRO_IZQUIERDA_TOPE);
int tope_dcha = digitalRead (GIRO_DERECHA_TOPE);
if (posgiro1 > 537 && tope_izq != HIGH ) { //Si tenemos el joystick girado a la izquierda y no está activo su FDC entramos en el bucle
digitalWrite (GIRO_DERECHA, LOW); //Apagamos el led de giro a la derecha
digitalWrite (GIRO_IZQUIERDA, HIGH); //Encendemos el led de giro a la izquierda
digitalWrite (LED_DCHA, LOW); //Ponemos a baja la salida del giro a la derecha
digitalWrite (LED_IZQ, HIGH); //Ponemos a alta la salida del giro a la izquierda
digitalWrite (LED_DCHA_TOP, LOW); //Apagamos el led de dirección girada al máximo a la derecha
//Serial.println ("giroizquierda");
}
else if (posgiro1 < 487 && tope_dcha != HIGH) { //Si por el contrario tenemos el joystick girado a la derecha y no está activo su FDC entramos en el bucle
digitalWrite (GIRO_IZQUIERDA, LOW); //Apagamos el led de giro a la izquierda
digitalWrite (GIRO_DERECHA, HIGH); //Encendemos el led de giro a la derecha
digitalWrite (LED_IZQ, LOW); //Ponemos a baja la salida del giro a la izquierda
digitalWrite (LED_DCHA, HIGH); //Ponemos a alta la salida del giro a la derecha
digitalWrite (LED_IZQ_TOP, LOW); //Apagamos el led de dirección girada al máximo a la izquierda
//Serial.println ("giroderecha");
}
else if (tope_dcha == HIGH){ //En caso de que la dirección esté girada al máximo a la derecha
digitalWrite (LED_DCHA_TOP, HIGH); //Encendemos el led que lo indica
digitalWrite (GIRO_DERECHA, LOW);
// digitalWrite (LED_IZQ_TOP, LOW);
}
else if (tope_izq == HIGH){ //En caso de que la dirección esté girada al máximo a la izquierda
digitalWrite (LED_IZQ_TOP, HIGH); //Encendemos el led que lo indica
digitalWrite (GIRO_IZQUIERDA, LOW);
// digitalWrite (LED_DCHA_TOP, LOW);
}
else { //En cualquier otro caso, siginifica que no estamos moviendo el joystick sobre el eje X
digitalWrite (GIRO_IZQUIERDA, LOW); //Ponemos a baja la salida del giro a la izquierda
digitalWrite (GIRO_DERECHA, LOW); //Ponemos a baja la salida del giro a la derecha
digitalWrite (LED_DCHA, LOW); //Ponemos a baja el led de giro a la derecha
digitalWrite (LED_IZQ, LOW); //Ponemos a baja el led de giro a la izquierda
//Serial.println ("paro");
//Serial.println (posgiro1);
}
// Serial.println (digitalRead(GIRO_IZQUIERDA_TOPE));
// Serial.println (digitalRead(GIRO_DERECHA_TOPE));
}
/* CONFIGURACION uC */
//Al setup() solo se entra en el arranque del Arduino y sirve para hacer las condiguraciones que hagan falta.
void setup() {
TCCR0B = (TCCR0B & 0xF8) | 0x02; //Configuramos el TMR0 para saque el PWM a 7815kHz en los pines 7 y 13
//Configuramos los pines segun sean (E/S)
pinMode (MOTOR_AV, OUTPUT); //PWM para el avance
pinMode (MOTOR_RETR, OUTPUT); //PWM para el retroceso
pinMode (LED_AVANCE, OUTPUT); //Led indicador avance motor
pinMode (LED_PARO, OUTPUT); //Led indicador "punto muerto"
pinMode (LED_RETROCESO, OUTPUT); //Led indicador retroceso motor
pinMode (LED_IZQ, OUTPUT); //Led indicador del giro hacia la izquierda
pinMode (LED_IZQ_TOP, OUTPUT); //Led indicador que la dirección está girada al máximo a la izquierda
pinMode (LED_DCHA, OUTPUT); //Led indicador del giro hacia la derecha
pinMode (LED_DCHA_TOP, OUTPUT);
pinMode (LUCES, OUTPUT);
pinMode (LUCES_PULSADOR,INPUT);
digitalWrite(LUCES_PULSADOR, HIGH);
attachInterrupt(0, luces, RISING); //Llamada a la interrupción para las luces.
//attachInterrupt(3, standby, RISING); //Llamada a la interrupción para el modo sleep.
Serial.begin(9600); //Iniciamos la comunicacion Serial
Ethernet.begin(mac,ip); //Iniciamos la conexion ethernet con la direccion MAC e IP asignadas
server.begin(); //Iniciamos el servidor
Serial.print("servidor en ip: "); //Imprimos por serie el la direccion IP del servidor
Serial.println(Ethernet.localIP());
}
/* PROGRAMA PRINCIPAL */
void loop(){
//En el programa principal se chequea continuamente el valor del interruptor de modo y según su posición se va a una rutina u otra.
SELECTOR_POS = analogRead (SELECTOR); //Variable para guardar la posicion del selector de modo
SELECTOR_POS = map (SELECTOR_POS, 0, 800, 0, 3); //Mapeamos el valor para tener solo 4 casos
//Serial.println(SELECTOR_POS);
switch (SELECTOR_POS) { //Segun sea el valor iremos a un caso o a otro
case 3:
// Serial.println("Local 1");
local1(); //Vamos al modo local1
break; //Salimos del switch
case 0:
Serial.println("Local 2");
// client.stop();
local2(); //Vamos al modo local2
volante(); //Vamos a la dirección
break;
case 1:
Serial.println("Standby");
standby(); //Vamos al modo standby
break;
case 2:
//Serial.println("Remoto");
remoto(); //Vamos al modo remoto
break;
};
}
B.2 Código LiveCode carta “principal”
global laURL on preOpenCard put "http://192.168.1.2:1025" into laURL end preOpenCard on OpenCard put "La URL es: " & laURL into the field URLField end OpenCard
B.3 Código LiveCode botón “modo”
on mouseUp go to card "conduccion" end mouseUp
B.4 Código LiveCode botón “configuracion”
on mouseUp go to card "configuracion" end mouseUp
B.5 Código LiveCode botón “volver”
global laURL global direccion global puerto on mouseUp put the text of field URLField into direccion put the text of field PuertoField into puerto if direccion is empty or puerto is empty then answer "Rellene los campos" else put "http://" & direccion & ":" & puerto into laURL answer "La URL es:" && laURL go to card "principal" end if end mouseUp
B.6 Código LiveCode botón “pulgar”
global laURL global traccion global alarmID global emergency on mouseDown mobileStartTrackingSensor "rotation rate", false -- put currentTime into previousTime put 0 into emergency put 1 into traccion -- put 1024 into roll -- put 0 into pitchRate -- put 0 into rollRate -- put 1024 into pitch send "alarm" to card "conexion" in 200 millisecs put the result into alarmID load URL laURL with message "URLDescargada" -- hide button "ModoVolver" end mouseDown on mouseUp mobileStopTrackingSensor "rotation rate", false put 0 into traccion cancel alarmID -- hide the button ErrorCheck -- hide the button ConexionCheck -- show button "ModoVolver" hide image ledrojo hide image ledamarillo show image ledverde end mouseUp
B.7 Código LiveCode botón “giro”
global laURL global giro global alarmID global emergency on mouseDown mobileStartTrackingSensor "rotation rate", false -- put currentTime into previousTime put 0 into emergency -- put 0 into pitchRate -- put 1024 into pitch send "alarm" to card "conexion" in 200 millisecs put the result into alarmID
put 1 into giro load URL laURL with message "URLDescargada" -- hide button "ModoVolver" end mouseDown on mouseUp mobileStopTrackingSensor "rotation rate", false put 0 into giro cancel alarmID -- hide the button ErrorCheck -- hide the button ConexionCheck -- show button "ModoVolver" hide image ledrojo hide image ledamarillo show image ledverde end mouseUp
B.8 Código LiveCode botón “retroceso”
global velocidad on mouseUp put 2 into velocidad show button avance show button paro hide button retroceso end mouseUp
B.9 Código LiveCode botón “paro”
global velocidad on mouseUp put 0 into velocidad show button avance hide button paro show button retroceso end mouseUp
B.10 Código LiveCode botón “avance”
global velocidad on mouseUp put 1 into velocidad hide button avance
show button paro show button retroceso end mouseUp
B.11 Código LiveCode botón “volver”
on mouseUp go to card "inicio" end mouseUp
B.12 Código LiveCode carta “conducción”
global laURL global alarmID global traccion global pitch global roll global previousTime global pitchRate global rollRate global acelerador global emergency global giro global velocidad on preOpenCard -- mobileStartTrackingSensor "rotation rate", false put "http://192.168.1.2:80" into laURL put laURL into field LabelField put 0 into roll put 0 into pitchRate put 0 into rollRate put 0 into pitch end preOpenCard on URLDescargada pURL, pURLStatus cancel alarmID -- rotationRateChanged if traccion = 1 or giro = 1 then if pURLStatus is "downloaded" then //Si se ha descargado la URL la ponemos en los campos put the word 1 of URL pURL into field SentidoField put the word 2 of URL pURL & "%" into field AceleradorField put the word 3 of URL pURL into field DireccionField
put URL pURL into field NewField unload URL pURL //Borramos la URL para poder cargar una nueva hide image "ledrojo" show image "ledverde" hide image "ledamarillo" else show image "ledrojo" hide image "ledverde" hide image "ledamarillo" -- show button ErrorCheck -- hide button ConexionCheck end if send "alarm" to card "conexion" in 200 millisecs put the result into alarmID updateRotation if emergency = 1 then put 1024 into roll put 1024 into pitch end if put "http://192.168.1.2:80/?" & velocidad & "," & roll & "," & pitch into pURL put pURL into field Z1Field load URL pURL with message "URLDescargada" end if end URLDescargada /* Evento para el led de conexión */ /* Si han transcurrido 40mS desde que se inició la conexión y no se ha descargado la URL entonces se enciende el led amarillo */ on alarm hide image "ledverde" show image "ledamarillo" hide image "ledrojo" -- show button ConexionCheck -- hide button ErrorCheck -- set the hilite of button ErrorCheck to false -- set the hilite of button ConexionCheck to true end alarm on updateRotation put the milliseconds into nowTime -- Integrar los datos del giróscopo if giro = 1 then add pitchRate * (nowTime - previousTime) to pitch end if if traccion = 1 then add rollRate * (nowTime - previousTime) to roll
end if put nowTime into previousTime /* Valores máximos */ /* Roll es el avance del coche, va de 0 a 2046 */ if roll < 0 then put 0 into roll end if if roll > 2046 then put 2046 into roll end if if pitch < 0 then put 0 into pitch end if if pitch > 1023 then put 1023 into pitch end if end updateRotation on rotationRateChanged x, y, z if giro = 1 then put x into pitchRate end if if traccion = 1 then put y into rollRate end if put pitch into field XField put roll into field YField put y into field ZField updateRotation end rotationRateChanged
ANEXO C
Hojas de datos
IFZ44N
IRF9540
CNX82
LM298
DISPLAY 7 SEGMENTOS
HCF4511
74LS48
70HFR120
IRFZ44NHEXFET® Power MOSFET
01/03/01
Parameter Typ. Max. UnitsRθJC Junction-to-Case ––– 1.5RθCS Case-to-Sink, Flat, Greased Surface 0.50 ––– °C/WRθJA Junction-to-Ambient ––– 62
Thermal Resistance
www.irf.com 1
VDSS = 55V
RDS(on) = 17.5mΩ
ID = 49AS
D
G
TO-220AB
Advanced HEXFET® Power MOSFETs from InternationalRectifier utilize advanced processing techniques to achieveextremely low on-resistance per silicon area. This benefit,combined with the fast switching speed and ruggedizeddevice design that HEXFET power MOSFETs are wellknown for, provides the designer with an extremely efficientand reliable device for use in a wide variety of applications.
The TO-220 package is universally preferred for allcommercial-industrial applications at power dissipationlevels to approximately 50 watts. The low thermalresistance and low package cost of the TO-220 contributeto its wide acceptance throughout the industry.
! Advanced Process Technology! Ultra Low On-Resistance! Dynamic dv/dt Rating! 175°C Operating Temperature! Fast Switching! Fully Avalanche Rated
Description
PD - 94053
Absolute Maximum RatingsParameter Max. Units
ID @ TC = 25°C Continuous Drain Current, VGS @ 10V 49ID @ TC = 100°C Continuous Drain Current, VGS @ 10V 35 AIDM Pulsed Drain Current " 160PD @TC = 25°C Power Dissipation 94 W
Linear Derating Factor 0.63 W/°CVGS Gate-to-Source Voltage ± 20 VIAR Avalanche Current" 25 AEAR Repetitive Avalanche Energy" 9.4 mJdv/dt Peak Diode Recovery dv/dt # 5.0 V/nsTJ Operating Junction and -55 to + 175TSTG Storage Temperature Range
Soldering Temperature, for 10 seconds 300 (1.6mm from case )°C
Mounting torque, 6-32 or M3 srew 10 lbf•in (1.1N•m)
Document Number: 91078 www.vishay.comS11-0512-Rev. B, 21-Mar-11 1
This datasheet is subject to change without notice.THE PRODUCT DESCRIBED HEREIN AND THIS DATASHEET ARE SUBJECT TO SPECIFIC DISCLAIMERS, SET FORTH AT www.vishay.com/doc?91000
Power MOSFET
IRF9540, SiHF9540Vishay Siliconix
FEATURES• Dynamic dV/dt Rating
• Repetitive Avalanche Rated
• P-Channel
• 175 °C Operating Temperature
• Fast Switching
• Ease of Paralleling
• Simple Drive Requirements
• Compliant to RoHS Directive 2002/95/EC
DESCRIPTIONThird generation Power MOSFETs from Vishay provide thedesigner with the best combination of fast switching,ruggedized device design, low on-resistance andcost-effectiveness. The TO-220AB package is universally preferred for allcommercial-industrial applications at power dissipationlevels to approximately 50 W. The low thermal resistanceand low package cost of the TO-220AB contribute to itswide acceptance throughout the industry.
Notesa. Repetitive rating; pulse width limited by maximum junction temperature (see fig. 11).b. VDD = - 25 V, starting TJ = 25 °C, L = 2.7 mH, Rg = 25 :, IAS = - 19 A (see fig. 12).c. ISD d - 19 A, dI/dt d 200 A/µs, VDD d VDS, TJ d 175 °C.d. 1.6 mm from case.
PRODUCT SUMMARYVDS (V) - 100
RDS(on) (:) VGS = - 10 V 0.20
Qg (Max.) (nC) 61
Qgs (nC) 14
Qgd (nC) 29
Configuration Single
S
G
D
P-Channel MOSFET
TO-220AB
GDS
Available
RoHS*COMPLIANT
ORDERING INFORMATIONPackage TO-220AB
Lead (Pb)-freeIRF9540PbFSiHF9540-E3
SnPbIRF9540SiHF9540
ABSOLUTE MAXIMUM RATINGS (TC = 25 °C, unless otherwise noted)PARAMETER SYMBOL LIMIT UNITDrain-Source Voltage VDS - 100
V Gate-Source Voltage VGS ± 20
Continuous Drain Current VGS at - 10 VTC = 25 °C
ID- 19
ATC = 100 °C - 13Pulsed Drain Currenta IDM - 72Linear Derating Factor 1.0 W/°C Single Pulse Avalanche Energyb EAS 640 mJ Repetitive Avalanche Currenta IAR - 19 A Repetitive Avalanche Energya EAR 15 mJ Maximum Power Dissipation TC = 25 °C PD 150 W Peak Diode Recovery dV/dtc dV/dt - 5.5 V/ns Operating Junction and Storage Temperature Range TJ, Tstg - 55 to + 175
°C Soldering Recommendations (Peak Temperature) for 10 s 300d
Mounting Torque 6-32 or M3 screw10 lbf · in1.1 N · m
* Pb containing terminations are not RoHS compliant, exemptions may apply
6
1
FEATURES• Input/Output pin distance 10.16 mm• UL recognized (File # E90700)
DESCRIPTIONThe CNX82A.W, CNX83A.W, SL5582.W AND SL5583.W,consist of a gallium arsenide infrared emitting diode driving asilicon phototransistor in a 6-pin dual in-line package.
2
1
3 NC
5
6NC
SCHEMATIC
PIN 1. ANODE 2. CATHODE 3. NO CONNECTION 4. EMITTER 5. COLLECTOR 6. NO CONNECTION
CNX82A.WSL5582.W
PIN 1. ANODE 2. CATHODE 3. NO CONNECTION 4. EMITTER 5. COLLECTOR 6. BASE
CNX83A.WSL5583.W
4
2
1
3 NC
5
6
4
6-PIN PHOTOTRANSISTOROPTOCOUPLERS
CNX82A.W, CNX83A.W, SL5582.W & SL5583.W
APPLICATIONS • Power supply regulators• Digital logic inputs• Microprocessor inputs
PACKAGE DIMENSIONS
SEAT
ING
PLA
NE
0.016 (0.40)0.008 (0.20)
0.070 (1.78)0.045 (1.14)
0.350 (8.89)0.330 (8.38)
0.154 (3.90)0.100 (2.54)
0.200 (5.08)0.115 (2.92)
0.004 (0.10)MIN
0.270 (6.86)0.240 (6.10)
0.400 (10.16)TYP
0° to 15°0.022 (0.56)0.016 (0.41)
0.100 (2.54) TYP
NOTEAll dimensions are in inches (millimeters)
4/13/00 200024D
Parameter Symbol Value UnitsTOTAL DEVICE
TSTG -55 to +150 °CStorage TemperatureOperating Temperature TOPR -55 to +100 °CLead Solder Temperature TSOL 260 for 10 sec °CJunction Temperature TJ 125 °CTotal Device Power Dissipation @ TA = 25°C PD 250 mW
EMITTERIF 100 mADC/Average Forward Input Current
Reverse Input Voltage VR 5.0 VForward Current - Peak (1µs pulse, 300pps) IF(pk) 3.0 ALED Power Dissipation @ TA = 25°C
PD140 mW
Derate above 25°C 1.33 mW/°CDETECTOR
VCEO 50 VCollector-Emitter VoltageCollector-Base Voltage (CNX83A) VCBO 70 VEmitter-Collector Voltage VECO 7 VContinuous Collector Current IC 100 mADetector Power Dissipation @ TA = 25°C
PD150 mW
Derate above 25°C 2.0 mW/°C
ABSOLUTE MAXIMUM RATINGS
L298
Jenuary 2000
DUAL FULL-BRIDGE DRIVER
Multiwatt15
ORDERING NUMBERS : L298N (Mult iwatt Vert. )L298HN (Mult iwatt Horiz.)L298P (PowerSO20)
BLOCK DIAGRAM
.OPERATING SUPPLY VOLTAGE UP TO 46 V. TOTAL DC CURRENT UP TO 4 A. LOW SATURATION VOLTAGE.OVERTEMPERATURE PROTECTION. LOGICAL ”0” INPUT VOLTAGE UP TO 1.5 V(HIGH NOISE IMMUNITY)
DESCRIPTIONThe L298 is an integrated monolithic circuit in a 15-lead Multiwatt and PowerSO20 packages. It is ahigh voltage, high current dual full-bridge driver de-signedto acceptstandardTTL logic levels anddriveinductive loads such as relays, solenoids, DC andsteppingmotors. Two enableinputs are provided toenableor disable the deviceindependentlyof thein-put signals. The emitters of the lower transistors ofeach bridge are connected togetherand the corre-spondingexternal terminal can be used for the con-
nectionofanexternalsensingresistor.Anadditionalsupply input is provided so that the logic works at alower voltage.
PowerSO20
1/13
TDSR1350, TDSR1360www.vishay.com Vishay Semiconductors
Rev. 1.3, 17-Apr-13 1 Document Number: 85180
For technical questions, contact: [email protected] DOCUMENT IS SUBJECT TO CHANGE WITHOUT NOTICE. THE PRODUCTS DESCRIBED HEREIN AND THIS DOCUMENT
ARE SUBJECT TO SPECIFIC DISCLAIMERS, SET FORTH AT www.vishay.com/doc?91000
High Intensity Red Low Current 7-Segment Display
DESCRIPTIONThis series defines a new standard for low current displays. It is a single digit 7-segment LED display utilizing AllnGaP technology in color red.
The supreme light intensity allows applications under direct sunlight or “black front” designs by using tinted filter glass in front of the display.
Typical 1500 µcd at 1 mA is best in class performance for applications with very limited power supply. The maximum forward current of 10 mA is allowed for an ambient temperature range of - 40 °C to + 85 °C without current derating.
Crosstalk between segments is possible at drive currents above 5 mA per segment. Therefore it is recommend to apply more than 5 mA only under direct sunlight or with tinted filter glass.
FEATURES• 1500 µcd typical at 1 mA
• Very low power consumption
• Wide viewing angle
• Grey package surface
• Light intensity categorized at IF = 1 mA
• Material categorization: For definitions of compliance please see www.vishay.com/doc?99912
APPLICATIONS• Battery driven instruments
• Telecom devices
• Home appliances
• Instrumentation
• POS terminals
PRODUCT GROUP AND PACKAGE DATA• Product group: Display
• Package: 13 mm
• Product series: Low current
• Angle of half intensity: ± 50°
19237
PARTS TABLE
PART COLORLUMINOUS INTENSITY
(µcd)atIF
(mA)
WAVELENGTH(nm)
atIF
(mA)
FORWARD VOLTAGE(V)
atIF
(mA)CIRCUITRY
MIN. TYP. MAX. MIN. TYP. MAX. MIN. TYP. MAX.TDSR1350 Red 280 - 3600 1 - 640 - 1 - 1.8 2.4 1 Common anode
TDSR1360 Red 280 - 3600 1 - 640 - 1 - 1.8 2.4 1 Common cathode
TDSR1360-IK Red 1100 - 3600 1 - 640 - 1 - 1.8 2.4 1 Common cathode
ABSOLUTE MAXIMUM RATINGS (Tamb = 25 °C, unless otherwise specified)�TDSR1350, TDSR1360, TDSR1360-IKPARAMETER TEST CONDITION SYMBOL VALUE UNITReverse voltage per segment VR 5 V
DC forward current per segment IF 10 mA
Peak forward current per segment tp d 10 µs, duty cycle 1/10 IFM 50 mA
Power dissipation Tamb d 85 °C PV 185 mW
Junction temperature Tj 105 °C
Operating temperature range Tamb - 40 to + 85 °C
Storage temperature range Tstg - 40 to + 85 °C
Soldering temperature t d 3 s, 2 mm below seating plane Tsd 260 °C
Thermal resistance LED junction/ambient RthJA 100 K/W
1/13October 2002
■ HIGH OUTPUT SOURCING CAPABILITY (up to 25mA).
■ INPUT LATCHES FOR BCD CODE STORAGE
■ LAMP TEST AND BLANKING CAPABILITY.■ 7-SEGMENT OUTPUTS BLANKED FOR BCD
INPUT CODES > 1001■ QUIESCENT CURRENT SPECIF. UP TO 20V■ STANDARDIZED SYMMETRICAL OUTPUT
CHARACTERISTICS■ 5V, 10V, AND 15V PARAMETRIC RATINGS■ INPUT LEAKAGE CURRENT
II = 100nA (MAX) AT VDD = 18V TA = 25°C■ 100% TESTED FOR QUIESCENT CURRENT ■ MEETS ALL REQUIREMENTS OF JEDEC
JESD13B "STANDARD SPECIFICATIONS FOR DESCRIPTION OF B SERIES CMOS DEVICES"
DESCRIPTIONHCF4511B is a monolithic integrated circuitfabricated in Metal Oxide Semiconductortechnology available in DIP and SOP packages. HCF4511B is a BCD to 7 segment decoder drivermade up of CMOS logic and n-p-n bipolartransistor output devices on a single monolithicstructure. This device combines the low quiescent
power dissipation and high noise immunityfeatures of CMOS with n-p-n bipolar outputtransistor capable of sourcing up to 25mA. Thiscapability allows HCF4511B to drive LEDs andother displays directly.Lamp Test (LT), Blanking (BL), and Latch Enableor Strobe inputs are provided to test the display,shut off or intensity-modulate it, and store orstrobe a BCD code, respectively. Several differentsignals may be multiplexed and displayed whenexternal multiplexing circuitry is used.
HCF4511B
BCD TO SEVEN SEGMENT LATCH/DECODER/DRIVER
PIN CONNECTION
ORDER CODES PACKAGE TUBE T & R
DIP HCF4511BEYSOP HCF4511BM1 HCF4511M013TR
DIP SOP
TL/F/10172
DM
74LS48
BC
Dto
7-S
egm
entD
ecoder
January 1992
DM74LS48BCD to 7-Segment Decoder
General DescriptionThe ’LS48 translates four lines of BCD (8421) input datainto the 7-segment numeral code and provides seven corre-sponding outputs having pull-up resistors, as opposed tototem pole pull-ups. These outputs can serve as logic sig-nals, with a HIGH output corresponding to a lighted lampsegment, or can provide a 1.3 mA base current to npn lamp
driver transistors. Auxiliary inputs provide lamp test, blank-ing and cascadable zero-suppression functions.
The ’LS48 decodes the input data in the pattern indicated inthe Truth Table and the segment identification illustration.
Connection Diagram
Dual-In-Line Package
TL/F/10172–1
Order Number DM74LS48M or DM74LS48N
See NS Package Number M16A or N16E
C1995 National Semiconductor Corporation RRD-B30M105/Printed in U. S. A.
Document Number: 93521 For technical questions, contact: [email protected] www.vishay.comRevision: 25-May-09 1
Standard Recovery Diodes(Stud Version), 70 A
70HF(R) SeriesVishay Semiconductors
FEATURES• High surge current capability• Designed for a wide range of applications• Stud cathode and stud anode version• Leaded version available• Types up to 1600 V VRRM
• Compliant to RoHS directive 2002/95/EC• Designed and qualified for industrial level
TYPICAL APPLICATIONS• Converters• Power supplies• Machine tool controls• Battery charges
ELECTRICAL SPECIFICATIONS
PRODUCT SUMMARYIF(AV) 70 A
DO-203AB (DO-5)
MAJOR RATINGS AND CHARACTERISTICS
PARAMETER TEST CONDITIONS70HF(R)
UNITS10 TO 120 140/160
IF(AV)70 70 A
TC 140 110 °C
IF(RMS) 110 A
IFSM50 Hz 1200
A60 Hz 1250
I2t50 Hz 7100
A2s60 Hz 6450
VRRM Range 100 to 1200 1400/1600 V
TJ - 65 to 180 - 65 to 150 °C
VOLTAGE RATINGS
TYPENUMBER
VOLTAGECODE
VRRM, MAXIMUM REPETITIVE PEAK
REVERSE VOLTAGEV
VRSM, MAXIMUM NON-REPETITIVE PEAK
REVERSE VOLTAGEV
VR(BR), MINIMUMAVALANCHE
VOLTAGEV
IRRM MAXIMUMAT TJ = TJ MAXIMUM
mA
70HF(R)
10 100 200 200
1520 200 300 300
40 400 500 500
60 600 720 725
980 800 960 950
100 1000 1200 1150
120 1200 1440 1350
140 1400 1650 15504.5
160 1600 1900 1750
ANEXO D
Glosario
A
Analógica: Se refiere a aquel tipo de electrónica en que las medidas pueden tomar cualquier valor infinitesimal, en lugar de utilizar lógica digital (todo o nada)
Ánodo: Parte del diodo que debe tener una tensión mayor para que éste se polarice y pueda conducir.
B
Bluetooth: Método de comunicación inalámbrica entre dos dispositivos mediante un enlace de radiofrecuancia de 2,4 GHz
Booleano: Lógica basada en dos únicos estados. Todo o Nada
Bootloader: Programa sencillo que tiene las funciones necesarias para que arranque el dispositivo.
Brushless: Tipo de motor eléctrico que en lugar de usar escobillas funciona mediante el cambio de polaridad en el rotor.
Bug: Es un error o fallo en un programa de computador o sistema de software que desencadena un resultado indeseado.
C
Cátodo: Parte del diodo que debe tener una tensión menor para que éste se polarice y pueda conducir.
Colector abierto o Open-collector: Es un tipo de solución que se encuentra en numerosos circuitos integrados. En lugar de aplicar directamente la tensión o corriente de salida, ésta se aplica a la base de un transistor NPN cuyo colector es la salida del circuito. El emisor del transistor se conecta internamente a tierra.
D
Datasheet: Hoja de datos que proporciona el fabricante del componente para que el usuario sepa todos los datos relativos al componente.
Devanado: Es el conjunto de espiras destinado a producir el flujo magnético, al ser recorrido por la corriente eléctrica.
Diodo: Un diodo es un componente electrónico de dos terminales que permite la circulación de la corriente eléctrica a través de él en un solo sentido.
Display: Es un dispositivo que poseen ciertos aparatos electrónicos que permite mostrar información al usuario de manera visual.
E
Estator: El estátor es la parte fija de una máquina rotativa y uno de los dos elementos fundamentales para la transmisión de potencia
Ethernet: Es un estándar de redes de área local para computadores.
F
Fritzing: Es un programa de automatización de diseño electrónico libre que busca ayudar a diseñadores y artistas para que puedan pasar de prototipos (usando, por ejemplo, placas de pruebas) a productos finales.
Fuerza electromotriz: Es toda causa capaz de mantener una diferencia de potencial entre dos puntos de un circuito abierto o de producir una corriente eléctrica en un circuito cerrado. Es una característica de cada generador eléctrico.
G
Gate-driver: Chip que se utiliza para un correcto funcionamiento de las puertas (gates) de los MOSFETs
Giróscopo: Es un dispositivo que sirve para medir cambios en un aparato.
H
Hardware: Se refiere a todas las partes tangibles de un sistema informático; sus componentes son: eléctricos, electrónicos, electromecánicos y mecánicos.
Híbrido: Es aquel vehículo que utiliza una mezcla de tecnologías para su propulsión (motor de combustión interna y motor eléctrico)
I
Inductancia: Es una medida de la oposición a un cambio de corriente de un inductor o bobina que almacena energía en presencia de un campo magnético
Insoladora: Aparato que se utiliza para poder “grabar” el fotolito sobre la placa de cobre fotosensible.
iOS: Sistema operativo que desarrolló Apple para sus dispositivos móviles.
L
LED: Light Emitter Diode. Acrónimo ingles de diodo emisor de luz.
Loop: Se llama loop al bucle “infito” del programa principal de Arduino
M
Mac OS X: Sistema operativo que desarrolló Apple para sus ordenadores.
Microcontrolador: es un circuito integrado programable, capaz de ejecutar las órdenes grabadas en su memoria. Está compuesto de varios bloques funcionales, los cuales cumplen una tarea específica. Un microcontrolador incluye en su interior las tres principales unidades funcionales de una computadora: unidad central de procesamiento, memoria y periféricos de entrada/salida.
MOSFET: Transistor de Efecto Campo Metal-Óxido Semiconductor. es un transistor utilizado para amplificar o conmutar señales electrónicas.
Multímetro: Dispositivo electrónico que sirve para medir tensiones, corrientes, resistencias, diodos, condensadores, …
O
Optoacoplador: también llamado optoaislador o aislador acoplado ópticamente, es un dispositivo de emisión y recepción que funciona como un interruptor activado mediante la luz emitida por un diodo LED que satura un componente optoelectrónico, normalmente en forma de fototransistor o fototriac.
P
PCB: Printed Circuit Board. Placa de circuito impreso. Es la placa donde se implementa físicamente el diseño electrónico.
Potenciómetro: Resistencia variable.
Protoboard: Placa de pruebas para pruebas electronicas.
PWM: Pulse Width Modulation. Modulación por Ancho de Pulsos. Es un método para conseguir de una forma aproximada, señales analógicas a partir de pulsos booleanos digitales.
T
Transistor: es un dispositivo electrónico semiconductor que cumple funciones de amplificador, oscilador, conmutador o rectificador.