Unidad de Control para Fresadora CNC con Cambio Automático de...

Unidad de Control para Fresadora CNC con

Cambio Automático de Herramienta

Proyecto Final de Carrera

Especialidad: Electrónica y Automática Industrial

AUTOR: Jorge Hermoso Fernández.

DIRECTOR: Alfonso Romero Nevado

Fecha: 05 / 2012

A Ángel por confiar en mí para desarrollar este producto, a Mar por revisar todo el trabajo, a Ricard por la magnífica labor de montaje y a todos aquellos que han participado de alguna u otra manera.

Muchas Gracias

4

Índice

1 Glosario ............................................................................................................... 9

1.1 Vocabulario .................................................................................................. 9

1.2 Acrónimos .................................................................................................. 10

2 Introducción ...................................................................................................... 11

2.1 Objetivos .................................................................................................... 11

2.2 Motivaciones .............................................................................................. 11

3 Descripción de un sistema de fresado ............................................................... 12

3.1 ATC (Automatic Tool Changer) ................................................................ 12

4 Descripción del proyecto ................................................................................... 14

4.1 Esbozo del sistema ..................................................................................... 14

4.1.1 Dimensiones ........................................................................................... 15

4.1.2 Funciones ............................................................................................... 15

4.1.3 Tipo de material para trabajar ................................................................ 16

4.1.4 Precisión ................................................................................................. 16

4.2 Sistema ATC y anclaje de herramientas .................................................... 16

4.3 Diseño mecánico del sistema ..................................................................... 17

4.4 Selección de actuadores y sensores ........................................................... 22

4.4.1 Necesidades ............................................................................................ 22

4.4.2 Restricciones .......................................................................................... 23

4.4.3 Selección ................................................................................................ 24

4.5 Requisitos de la unidad de control ............................................................. 28

4.6 Diseño de la unidad de control .................................................................. 28

4.6.1 Requisitos y elección driver motores ..................................................... 29

4.6.2 Requisitos y elección módem BT........................................................... 29

4.6.3 Requisitos y elección extras ................................................................... 30

4.6.4 Requisitos y elección uC ........................................................................ 31

4.6.5 Elección de un comicro .......................................................................... 32

4.6.6 Panel de Control ..................................................................................... 32

4.6.7 Etapa de alimentación ............................................................................ 33

5 Diseño y fabricación.......................................................................................... 34

5.1 Herramientas utilizadas para la elaboración de este proyecto ................... 34

5.1.1 Arduino IDE ........................................................................................... 34

5.1.2 Eclipse .................................................................................................... 34

5.1.3 WinAVR................................................................................................. 34

5

5.1.4 Android SDK.......................................................................................... 34

5.1.5 Altium Designer ..................................................................................... 34

5.1.6 Diseño de esquemáticos y variantes ....................................................... 35

5.1.7 Diseño del PCB ...................................................................................... 36

5.2 Fabricación de los prototipos ..................................................................... 36

5.2.1 Fabricación de prototipos del PCB......................................................... 36

5.2.2 PCB del Panel de Control ...................................................................... 36

5.2.3 Montaje de los prototipos ....................................................................... 37

5.3 Desarrollo software .................................................................................... 37

5.3.1 FKT IO ................................................................................................... 38

5.3.2 Heavy Duty ............................................................................................ 38

5.3.3 Aplicación de Configuración y Control Manual .................................... 38

Aplicación Comicro ........................................................................................... 41

Aplicación Android ............................................................................................ 43

6 Cálculos ............................................................................................................. 45

6.1 Consumo total de la unidad de Control ..................................................... 45

6.1.1 Peor caso 5V........................................................................................... 45

7 Planos ................................................................................................................ 47

8 Presupuesto........................................................................................................ 60

8.1 Estudio y diseño ......................................................................................... 60

8.2 Componentes ............................................................................................. 61

8.3 Fabricación de prototipos ........................................................................... 62

8.4 Desarrollo de SW ....................................................................................... 63

8.5 Generación de la documentación ............................................................... 63

8.6 Costes Globales del Proyecto .................................................................... 63

9 Conclusiones ..................................................................................................... 65

Referencias ............................................................................................................. 66

Apéndice A: Código Aplicación de Configuración (Eclipse IDE) ............................ 67

Apéndice B: Código Aplicación Configuración Comicro (Arduino IDE)................ 85

Apéndice C: Código Test IO (Arduino IDE) ............................................................. 96

Apéndice D: Código Test Heavy Duty (Eclipse IDE) ............................................... 97

Apéndice E: Aplicación Android ............................................................................... 98

Apéndice F: Variantes & PnP .................................................................................. 145

Apéndice G: BOM ................................................................................................... 151

Apéndice H: Planos Mecánicos ............................................................................... 152

6

Resumen

Título: Unidad de control para fresadora CNC con cambio automático de herramienta Autor: Jorge Hermoso Fernández Dirección: Alfonso Romero Nevado Fecha: Junio de 2012

0. Resumen

Los sistemas de mecanizado en la industria son elementos cada vez más comunes, siendo uno de los principales exponentes la fresadora por control numérico. La popularidad de estas máquinas ha ido creciendo hasta el punto de haberse convertido, incluso, en elementos disponibles para particulares y gracias, en gran medida, a las aplicaciones CAM.

En este proyecto se presenta una aproximación a un sistema de fresado por control númerico de sobremesa con cambio automático de herramienta mediante un carrusel dispensador. El propósito del sistema diseñado será el de poder validar el método de anclaje propuesto en el proyecto, así como las alternativas que puedan derivar. Es por ello que el conjunto se dimensiona de una forma escalada buscando una reducción de complejidad y de costes y utlizando servomotores de modelismo como alternativa a los motores paso a paso.

La fijación de la herramienta se ha previsto con un sistema imantado de corona dentada para facilitar el posicionamiento y reducir la complejidad de centraje y orientación presente en otros sistemas de cambio automático de herramienta.

A partir del esbozo del sistema de fresado se describirá el diseño y fabricación de una unidad de control capaz de controlar la máquina, siendo este el verdadero objetivo del presente proyecto. Esta unidad deberá permitir la comunicación con el PC y vía Bluetooth con dispositivos Android para el desarrollo de la futura aplicación de trabajo. Como ejemplo, se desarrollará una aplicación de configuración y control manual que muestre a los interesados el uso del sistema.

7

Resum

Títol: Unitat de control per a fresadora CNC amb canvi automátic d’eina. Autor: Jorge Hermoso Fernández Direcció: Alfonso Romero Nevado Data: Juny de 2012

0. Resum

Els sistemes de mecanitzat a la industria són elements cada cop més comuns, essent un del principals exponents la fresadora per control numèric. La popularitat d’aquestes màquines s’ha incrementat fins al punt d’haver-se convertit, fins i tot, en elements disponibles per a particulars gràcies, en gran mesura, a les aplicacions CAM.

En aquest projecte es presenta una aproximació a un sistema de fresat per control numèric de sobretaula amb canvi automàtic d’eina mitjançant un carrusel dispensador. El propòsit del sistema diseñat serà el de poder validar el mètode d’anclatge proposat al projecte així com les alternatives que es puguin derivar. És per això que el conjunt es dimensiona d’una forma escalada buscant una reducció de complexitat i de costos i utilitzant servomotors de modelisme com a alternativa als motors pas a pas.

La fixació de l’eina s’ha previst amb un sistema imantat de corona dentada per facilitar el posicionament i reduir la complexitat del centratge i orientació present en altres sistemes de canvi automàtic.

A partir de l’esboç del sistema de fresat es descriurà el disseny i la fabricació d’una unitat de control capaç de controlar la màquina, essent aquest el verdader objectiu del present projecte. Aquesta unitat haurà de permetere una comunicació USB amb l’ordinador i via Bluetooth amb un dispositiu Android per al desenvolupament d’una futura aplicació de treball. Com exemple es desenvoluparà una aplicació de configuració y control manual que mostri als interessats l’ús del sistema.

8

Final Project Summary Title: Control unit design for CNC milling machine with automatic tool changer Author: Jorge Hermoso Fernández Management: Alfonso Romero Nevado Date: June of 2012

0. Abstract

Industrial machining systems are increasingly common elements to be one of the leading exponents the numerically controlled milling machine. The popularity of these machines has grown as much as to become available for individuals thanks greatly to CAM applications.

This project presents an approach to a desktop numerical control milling system with automatic tool changer through a dispenser carousel. The main purpose of the designed system will be the validation of the fixing tool proposed in the document as well as several alternatives that may arise. Because of this the whole system will be accordingly sized to reduce complexity using hobby servomotors as an alternative to stepper motors.

The tool locking system is composed by a geared ring with a magnetic core to facilitate the positioning and centering as well as reducing complexity and orientation issues present in other automatic tool changer systems.

From the outline of the milling system this project will describe the design and manufacture of an electronic control unit capable of managing the machine, which is the main goal of this project. This unit will allow communication with the PC and via Bluetooth with Android devices for the development of future operating applications. As an example, a configuration and manual control application will be developed to show the reader the use of the system.

9

1 Glosario

1.1 Vocabulario

Arduino: plataforma de hardware de fuente abierta basada en una sencilla placa de entradas y salidas simple y un simple entorno de desarrollo.

Despanelizado: Operación de separación dels scoring (restos sobrantes de PCB) de un panel con diversos placas electrónicas.

Android: Sistema operativo para dispositivos móviles (smartphones y tablets) basado en un kernel de Linux.

Diodo de clamping: Diodos que se colocan entre una salida o entrada y alimentación y masa para asegurar los niveles de tensión de esta.

Firmware: bloque de instrucciones de máquina para propósitos específicos, grabado en una memoria de tipo de solo lectura.

iWrap: firmware especifico para modulos Bluetooth de Bluegiga que permite una gestión de las funcinalidades muy simple.

Comicro: microcontrolador secundario de una unidad electrónica con los objetivos de supervisar algunas operaciones del microcontrolador principal y liberarlo de cierta carga.

FTDI: Compañía escocesa de fabricación de semiconductores especializada en conversores serie-USB. Tal es su popularidad que se abrevia el nombre de estos a chips FTDI.

Footprint: Diseño de los pads de un componente electrónico para un PCB, es la uella necessaria para hacer las conexiones a los pines de este.

Conector IDC: Tipo de conector para cable plano caracterítico por ser de montaje fácil al quedar atrapado el cable entre unas pequeñas cuchillas que automáticamente cortan el aislamiento de plástico. Es muy popular en el hardware infrmático.

XML: Extensible Markup Language, se trata de un lenguaje estructural que permite la compatibilidad entre sistemas.

10

1.2 Acrónimos

CNC: Control Numérico por Computadora

CAM: Computer Aided Manufacturing

CAD: Computer Aided Design

PCB: Printed Circuit Board

ATC: Automatic Tool Changer

FSR: Force Sensing Resistor

LDR: Light Dependent Resistor

LED: Light Emitting Diode

PnP: Pick and Place

USART: Universal Synchronous/Asynchronous Receiver/Transmitter

BT: Bluetooth

IDE: Integrated Development Environment

SO (Encapsulado): Small Outline

11

2 Introducción

Las máquinas de fresado son elementos muy comunes en los ambientes industriales. Su uso se extiende desde la creación de piezas diseñadas mediante programas de CAD hasta la simple tarea de despanelizado de PCBs.

En un entorno cada vez más estricto con los tiempos de producción y la eficiencia, la automatización de los procesos se convierte poco a poco en una herramienta imprescindible.

2.1 Objetivos

El objetivo general del presente proyecto es proponer un modelo escalado de bajo coste de una fresadora automática de dos ejes con un sistema automático de cambio de herramientas por revólver.

A partir del esbozo del prototipo se pretende diseñar y fabricar una unidad de control electrónica capaz de controlar toda la máquina de forma escalada y de permitir al usuario la configuración del sistema y su uso mediante una conexión Bluetooth a un dispositivo móvil con el sistema operativo Android. Se deberán seleccionar los accionamientos y sensores necesarios del mercado para dimensionar la unidad de control. La aplicación host para el programa CAM no se desarrollará en el presente proyecto. Tampoco se construirá el prototipo del sistema CNC.

Al tratarse de un proyecto en la especialidad de electrónica y automática industrial esta memoria se centrará en el diseño y fabricación de la unidad de control así como en la elección de los sensores y actuadores, aunque la totalidad del proyecto se mostrará en el documento para permitir al lector una mejor comprensión de las necesidades de desarrollo.

Las conclusiones del proyecto académico se extraerán sobre los resultados de la fabricación del prototipo electrónico, mientras que la valoración externa del proyecto se basará en las diferentes pruebas de los sistemas de fijación para el sistema ATC (Automatic Tool Changer).

2.2 Motivaciones

Con este proyecto se trata de presentar una alternativa a los actuales sistemas de fresado mediante las conclusiones que se puedan extraer del estudio y diseño que nos ocupan.

La realización de este proyecto esta motivada por la necesidad de realizar un trabajo multidisciplinar que, si bien se encuentra claramente centrado en el desarrollo electrónico, requiere de planteamientos y herramientas del diseño mecánico. Es, por tanto, una excelente oportunidad para diseñar un sistema desde el inicio teniendo la libertad de tomar todas las decisiones.

12

3 Descripción de un sistema de fresado

La fresadora es una máquina de mecanizado por erosión cuyo primer modelo data de 1818 por Eli Whitney [1], un inventor estadounidense. Su principio de funcionamiento se basa en una herramienta rotativa de varios filos, llamada fresa, que elimina el material a su paso dando así forma a la pieza. Los primeros modelos, aunque poco efectivos, permitieron mediante el intercambio de piezas mecanizar diseños que no habrían sido posibles de fabricar en masa de otra forma.

A diferencia de un taladro corriente, la fresadora no está limitada a acceder a la pieza inmóvil en el banco de trabajo mediante el movimiento en un único eje, sino que la herramienta trabaja la pieza con libertad en los ejes horizontales permitiendo de esta manera la realización de formas complejas variando la posición de la pieza, el grado de inserción de la herramienta y el perfil de la fresa.

Por regla general, las fresadoras tienen precisiones de menos de 0.025mm gracias a sistemas reductores en caso de accionamiento manual (mediante manivelas) o a controles analógicos o digitales en los casos de sistemas automatizados.

Debido a su gran polivalencia las fresadoras son cada vez más comunes en el entorno industrial, pero con el avance tecnológico es raro encontrar fresadoras manuales. El control numérico por ordenador (CNC) ha permitido informatizar el mecanizado y, gracias a la conjunción de estas máquinas con del software de diseño y manufactura asistidos por ordenador (CAD y CAM), se han reducido los tiempos de producción.

La mayoría de fresadoras CNC, también llamadas “centros de mecanizado”, consisten en taladros verticales con libertad de movimiento en los tres ejes cartesianos. Aunque el movimiento vertical en el eje Z suele realizarlo el útil rotatorio, dependiendo de la arquitectura, hay maquinas que mueven la base con la pieza fija en los ejes planos X e Y, o bien otras que mueven la herramienta.

Los modelos más avanzados de fresadoras han llegado a incorporar hasta dos ejes más de trabajo, incorporando la rotación de la pieza como si de un torno se tratase, así como la inclinación de ésta, permitiendo a la herramienta trabajar en ángulo.

3.1 ATC (Automatic Tool Changer)

En este escenario de avanzada automatización de procesos es prácticamente indispensable intentar aumentar la eficiencia de las máquinas. Con tal efecto se introdujo el concepto de cambio automático de herramienta. Estos sistemas también son conocidos en el mundo de la robótica, aunque en este caso existen diferencias, al requerir no sólo la transmisión de movimiento, sino también la de señales eléctricas.

El ATC reduce los tiempos de fabricación al eliminar la necesidad de parar el proceso para permitir al operario acceder a cambiar la herramienta, con la posterior calibración. Además, permite el cambio automático en caso de rotura de herramientas frágiles.

De forma general, el cambio automático de herramienta consiste en un mecanismo de acceso y extracción más un cojunto de dos piezas que conforman un sistema de fijación mecánico siendo el lado de la máquina el anclaje maestro y la del lado de la herramienta el anclaje esclavo.

13

Entre los sistemas ATC para fresadoras, el más común con diferencia es el tipo “in line”, el cual consiste en una disposición en línea de todas las herramientas a lo largo de un eje exterior a la zona de trabajo. Este sistema presenta la principal ventaja de su simplicidad, además de la gran accesibilidad para colocar y recoger las herramientas, tanto por parte de la máquina como del operario. La alternativa a este sistema es el carrusel o revólver, el cual almacena las herramientas en un dispensador giratorio. Se trata de un sistema más complejo destinado sobretodo a grandes máquinas normalmente cerradas en las que interesa mantener la atmósfera interior y donde se busca proteger las herramientas de la suciedad. En este segundo caso es más común encontrar los sistemas de fijación maestro-esclavo arriba mencionados, mientras que en los sistemas en línea se suelen utilizar herramientas estándares, al igual que con los taladros convencionales, automatizando el movimiento de la mordaza del motor.

Imagen 1: Sistema lineal de cambio de herramienta [2]

Imagen 2: Sistema por carrusel de cambio de herramientas [3]

14

4 Descripción del proyecto

El proyecto tiene como objetivo el esbozo de un sistema de fresado, la elección de los actuadores y el diseño y fabricación de la placa de control, así como su interfaz de configuración mediante la aplicación Android.

Con el objetivo de facilitar al lector el seguimiento del presente documento, se ha divido el proceso de trabajo en diferentes secciones:

• En primer lugar, se realizará un breve esbozo del sistema que se pretende diseñar, señalando las características necesarias.

• Posteriormente, y en base a las ideas expuestas en el punto anterior, se listarán las necesidades del sistema en lo que se refiere a actuadores y sensores eléctricos.

• Con los requerimientos se realizará la búsqueda de los modelos necesarios en el mercado para la fabricación del sistema CNC.

• Una vez seleccionados los actuadores, se dimensionará la placa de control para seleccionar los componentes.

• Finalmente, se realizará el diseño y se procederá a documentar su fabricación y resultados.

4.1 Esbozo del sistema

La fresadora se plantea como un sistema CNC de sobremesa de tres ejes en los que se puede controlar el movimiento relativo entre la pieza y el útil en los tres ejes cartesianos. El accionamiento de la herramienta será un motor de corriente continua de baja potencia, pues se tratará de un sistema a pequeña escala para poder validar el sistema de fijación de herramientas y desarrollar la aplicación de control para terminales móviles.

Imagen 3: Ejes de trabajo de una fresadora

A pesar de que el diseño mecánico se basará en un sistema de tres ejes, la placa de control debe estar preparada para cinco ejes, añadiendo así la funcionalidad para tornear piezas con inclinación.

15

Para el sistema ATC se diseñará un modelo de revólver con desplazamiento en el eje horizontal, para permitir la fijación y extracción de la herramienta mediante unas guías. Este punto se discutirá más delante de forma más extensiva.

Imagen 4: Sistema ATC de carrusel con piñón y cremallera

4.1.1 Dimensiones

La máquina resultante debe ser una versión de escritorio, por lo que las dimensiones totales del sistema no deberán exceder los 600 x 600 mm. La superficie útil de trabajo será de 360 x 360 mm, a excepción de la zona de cambio de herramienta que le restará un área de 60 x 60 mm en una esquina.

4.1.2 Funciones

Con este sistema se espera, como principal resultado, mover el útil de fresado por todo el área activa horizontal, así como vertical, y poder realizar los cambios automáticos de herramienta.

Una vez conseguidos estos objetivos, el sistema deberá ser capaz de trabajar exclusivamente materiales blandos en dos y tres dimensiones, erosionando, taladrando, cortando o dibujando.

Una opción que debe contemplar el sistema de control es la funcionalidad como torno con la adición de hasta dos ejes más de trabajo, uno en el eje de la pieza a trabajar y otro perpendicular a este:

16

Imagen 5: Ejes de trabajo adicionales (izquierda: inclinación, derecha: rotación)

4.1.3 Tipo de material para trabajar

Al tratarse de un sistema a escala con accionamientos de baja potencia, se espera trabajar con materiales muy blandos como la espuma de poliestireno para diseños 2D y 3D. No obstante, el objetivo no es poder mecanizar materiales, sino poder evaluar el anclaje y su resistencia con un motor de baja potencia.

4.1.4 Precisión

Al tratarse de un sistema para el desarrollo, se busca conseguir una precisión aceptable, aunque no se presenta como un detalle crítico, de modo que éste es un parámetro con un margen muy abierto. Como sistema de posicionamiento, este proyecto prevé utilizar servomotores de 180º cuyas señales de control, de forma general, permiten una resolución de 1024 pasos para modelos digitales. En este escenario, la resolución esperada en los ejes horizontales es de:

360 mm/180 posiciones = 0.35 mm/paso

A este valor habría que añadir el error que pueda producir el sistema de transmisión por correa y engranajes.

4.2 Sistema ATC y anclaje de herramientas

El sistema de fijación en el cual se basa este proyecto consiste en cabezas con engranajes dentados en media V y núcleo imantado. De esta forma, es posible fijar la herramienta con poca presión gracias a la atracción magnética y a la forma de los dientes, pero la transmisión del movimiento rotativo es eficiente gracias al ensamblaje por la cara plana de los engranajes en el sentido correcto de giro.

17

Imagen 6: Sistema de fijación para ATC (izquierda maestro, derecha esclavo)

Por un lado, el eje del motor termina en una cabeza imantada que constituye la hembra del sistema de anclaje. Tal y como se aprecia en el modelo 3D, los dientes mecanizados en la pared interior sirven para acomodar y posicionar la herramienta al introducirla. Mientras los imanes mantienen unida la herramienta a la máquina, los dientes son los que transmiten la fuerza.

Este tipo de anclaje es útil siempre que la herramienta trabaje a presión. En casos en los que la herramienta pueda quedar atrapada en el material se pueden presentar problemas, aunque en este caso la resistencia de la unión vendrá dada por la velocidad de rotación y par de la fresadora.

El sistema de dientes en V asimétricos permite alinear correctamente la herramienta con el eje motor en el momento de la introducción de la herramienta sin necesidad de ningún control de la orientación del eje motor o de la herramienta.

Por último, el cabezal de la herramienta incluye una muesca que le permite introducirse en las guías del revolver porta-herramientas y, de esta manera, desanclarse del eje motor al desplazarse éste verticalmente.

Este tipo de anclaje es completamente original y, por tanto, no se han podido realizar pruebas hasta el momento. Con la máquina diseñada en este proyecto se pretende validar en el futuro la eficiencia de este anclaje, así como su utilidad para sistemas de cambio automático de herramienta.

4.3 Diseño mecánico del sistema

El diseño del sistema se presenta a continuación, mediante capturas del modelo 3D del sistema CNC creado al completo con el programa Solidworks. Se han tenido en cuenta todas las especificaciones anteriormente descritas y se han obviado todos los elementos irrelevantes al diseño para facilitar la comprensión del diseño (elementos de fijación, soportes, etc.).

18

Imagen 7: Vista 3D de la fresadora diseñada en Solidworks

Imagen 8: Fresadora con tapa abierta

Tal y como se puede observar, se ha planteado un sistema de transmisión por correas para los ejes X e Y en conjunto con un sistema de engranajes que permitirá transformar el recorrido típico de 180º de los servomotores en un desplazamiento lineal de 360 mm. El eje Y cuenta, además, con una correa paralela conducida para permitir un desplazamiento equilibrado.

Imagen 9: Detalle del sistema de engranaje

19

Para el eje Z este sistema paralelo no ha sido necesario, al tratarse de un desplazamiento menor, por lo cual se ha previsto un sistema de piñón y cremallera directamente sobre la base del motor de taladrado.

Otro sistema de piñón y cremallera es el utilizado para el desplazamiento lineal del revólver entre las posiciones de reposo y de carga.

En todos los sistemas de desplazamiento lineal los accionamientos no soportan el peso de las partes móviles, pues éste se libera mediante el uso de guías en las que se integran los bloques en movimiento, como se puede observar en el detalle a continuación.

Imagen 10: Detalle de guía mecanizada para soporte de peso

Finalmente, el giro del carrusel se ha planteado con el servo directamente acollado de forma concéntrica. Esta solución será apta siempre que se trabaje con un modelo de servomotor que admita trabajar a 360º. En caso contrario, se deberá modificar el diseño mecánico para permitir una reducción por engranajes.

Como se puede observar, la tapa del sistema posee una obertura para permitir la carga y descarga de herramientas, tal y como se expuso con anterioridad, según el proceso que se detalla a continuación.

Procedimiento de cambio de herramientas

El funcionamiento del sistema ATC diseñado es el siguiente:

1. Orden de cambio de herramienta. 2. Aproximación a la zona de cambio de herramienta. 3. Desplazamiento en -Z del útil. 4. Desplazamiento horizontal del revolver a la posición de cambio (herramienta

insertada en las guías del revolver). 5. Desplazamiento en +Z del útil con ligero giro anti horario del motor

(herramienta extraída). 6. Rotación del revolver hasta la posición de la herramienta seleccionada. 7. Desplazamiento en -Z del útil (inserción de la herramienta).

20

8. Desplazamiento horizontal del revolver a la posición de reposo (herramienta liberada del revolver).

9. Desplazamiento en +Z del útil a la posición de reposo. 10. Continuar el fresado.

Para resolver los inicios después de un reset de la estación, se incorporara un sensor de presencia que detectará qué espacios del revolver están vacíos. Para simplificar su funcionamiento, el carrusel deberá estar completo a excepción de la herramienta en uso. De esta manera, sólo quedará disponible un espacio para retornar la herramienta en el Power On de la máquina y se asegurará así que el orden de las herramientas se mantenga

Imagen 11: Vistas superior y frontal durante el cambio de herramienta

Imagen 12: Vistas superior y frontal durante el cambio de herramienta con tapa abierta

21

Imagen 13: Recorrido lineal del revólver entre

la posición de reposo y la posición de carga.

.

Procedimiento de carga semiautomático de herramientas

Para los casos en los que se tenga que reponer una herramienta del revólver (cambio de tipo o recambio), el proceso que deberá seguir el sistema es el siguiente:

1. Orden de carga de revólver. 2. Extracción automática de la herramienta en uso (el útil queda libre). 3. Desplazamiento del útil a la esquina opuesta a la posición de cambio. 4. El sistema cede el control al usuario para avanzar posición por posición. 5. El usuario cambia la herramienta manualmente a través del espacio de carga. 6. Desplazamiento del revólver a la posición de reposo. 7. Comprobación de posiciones vacías (si hay alguna vacía, se genera error).

Este proceso se denomina “semiautomático” porque el sistema en sí sigue gestionando algunos movimientos. El proceso manual se realizará sin alimentación y con la tapa abierta.

Todas las herramientas se suponen mecanizadas según el sistema de fijación descrito y diseñado por el autor de este proyecto.

22

Imagen 14: Ejemplo de herramienta con

cabezal para el sistema de fijación propuesto

4.4 Selección de actuadores y sensores

Con las características descritas en los puntos anteriores se puede perfilar el conjunto de actuadores y sensores necesarios y, posteriormente, la unidad de control del sistema completo.

4.4.1 Necesidades

Recogiendo los elementos del diseño se presentan las siguientes necesidades por parte del sistema de fresado CNC:

1. Accionamiento eléctrico para desplazamiento en X.

2. Control de posición en X.

3. Accionamiento eléctrico para desplazamiento en Y.

4. Control de posición en Y.

5. Accionamiento eléctrico para desplazamiento en Z.

6. Control de posición en Z.

7. Accionamiento rotatorio continuo para el fresado.

8. Control de presión para asegurar la presencia de la herramienta.

Por parte del sistema ATC:

1. Accionamiento lineal para la inserción y extracción de la herramienta.

2. Control de posición del accionamiento lineal.

3. Accionamiento rotatorio para la selección de herramienta.

4. Sensor de presencia para las herramientas.

23

Por parte de las extensiones:

1. Accionamiento rotatorio continuo para el torneado de las piezas.

2. Accionamiento rotatorio para la inclinación de la pieza.

3. Control de inclinación.

4.4.2 Restricciones

Para que el diseño sea fiel al requisito de la simplicidad y del coste se toman las siguientes decisiones respecto a los actuadores y sensores necesarios:

Respecto al sistema CNC

• Los accionamientos para los tres ejes serán servomotores digitales de alta resolución.

• El accionamiento para el fresado será un motor de 12V de menos de 1A • El control de presencia de la herramienta se realizará mediante un sensor de

presión en la base del anclaje del motor. • El eje Z contará con dos finales de carrera para asegurar la posición alta

(extracción herramienta) y baja (inserción de herramienta).

Respecto al ATC

• El accionamiento lineal será un motor DC de 12V con reductora y control de posición mediante finales de carrera.

• El accionamiento rotativo será un servomotor digital. • El sensor de presencia debe ser único y ajustable para todos los tipos de

herramientas.

Respecto a las extensiones

• Se preverá un control adicional para un motor DC de altas velocidades con reductora.

• Para asegurar la fijación de la pieza al eje de rotación se instalarán dos sensores de presión en los anclajes.

• Se preverá un control adicional para un servomotor para la inclinación de la pieza.

El funcionamiento de los motores DC se señalizará con indicadores LED para asegurar una correcta utilización.

24

4.4.3 Selección

Servomotores para los ejes

La característica principal que se busca en estos accionamientos es la precisión, además de un par adecuado para poder desplazar cada una de las estructuras móviles.

En el mercado se encuentran disponibles dos grandes grupos de servomotores de modelismo: los analógicos y los digitales. Para este proyecto se consideran necesarios los servomotores digitales, puesto que ofrecen más par y más precisión que un servo analógico de la misma categoría, con el único inconveniente de un consumo superior.

El modelo escogido es el HS-7975HB V2 de la casa Hitech. Se trata de un servo de alta resolución (2048 pasos para 90º) con un par de 8,6Kg·cm alimentado a 4.8V.

Imagen 15: Servomotor HS-7975HB [4]

Características:

Voltaje de operación: 4.8-6.0 V

Velocidad sin carga (4.8 V): 0.14 sec/60°

Par (4.8 V): 8.6 kg.cm

Consumo en parada (4.8 V): 3 mA

Consumo en funcionamiento (4.8 V): 200 mA – 2 A en carga máxima

Dimensiones: 40 x 20 x 37 mm

Peso: 53 g

El servo es programable a 180º y rotación continua. Se debe tener en cuenta que a 180º la resolución bajará a 1024 pasos. No obstante, a este valor deberíamos sumar la resolución del sistema de transmisión que se utilizará para transformar el recorrido de 180º en 360mm lineales y la precisión de la señal PWM que gobernará los servomotores.

Para facilitar la construcción, y a pesar de tener que trabajar con diferentes niveles de carga, se escogerá el mismo modelo para todos los ejes.

Servomotor para el revolver

El revólver porta-herramientas puede ser accionado por un servomotor de menor resolución y menor precio. Se sigue enfocando a modelos digitales debido a su menor deriva temporal y desgaste.

25

El modelo escogido es de la casa Hitech, al igual que el anterior, referencia HS-5065MG. Se trata de un servomotor digital de 180º con un par de 1.8Kg·cm.

Imagen 16: Servomotor HS-5065MG [4]

Características:

Voltaje de operación: 4.8-6.0 V

Velocidad sin carga (4.8 V): 0.14 sec/60°

Par (4.8 V): 1.8 kg.cm

Consumo en parada (4.8 V): 3 mA

Consumo en funcionamiento (4.8 V): 200 mA – 2 A en carga máxima

Dimensiones: 23.6 x 11.6 x 24 mm

Peso: 11.9 g

Servomotor para la inclinación

Al tratarse de una función de precisión, se escoge para esta tarea el mismo servomotor seleccionado para el posicionamiento de los ejes. De esta manera, se conseguirá la precisión óptima y se sobredimensionará el sistema para casos de piezas más pesadas, aunque no sea el escenario de este proyecto.

Motor DC para la fresadora

Es difícil incluir el motor de la fresadora como un motor DC controlado electrónicamente. En la mayoría de aplicaciones este motor se alimentaría con tensión de red. No obstante, en esta aplicación escalada se ha buscado el motor que mejor se pueda adaptar a las necesidades del proyecto.

El motor escogido es el GP32 0019 de Trident de 14W, proporcionando un par máximo de 2.25 Nm a una velocidad de hasta 5400rpm con un consumo máximo de 1.66A.

Se trata de un motor con caja reductora que permite obtener un buen equilibrio entre consumo, espacio y fuerza.

26

Imagen 17: Plano con dimensiones del motor GP32 0019 [5]

Motor DC para la aproximación del revolver

Para esta aplicación, la velocidad no es tan importante como el par, aunque en cualquier caso la carga que deberá soportar es mínima. Para asegurar un buen comportamiento se escoge un motor con caja reductora epicíclica, el 944d41 de Como Drills.

Imagen 18: Motor Como Drills 944d41 [5]

Tabla 1: Características del motor 944d41 [6]

Motor DC para el torneado

Para el torneado y rotación de la pieza se asumirá el mismo motor escogido para el desplazamiento lineal del revolver.

Sensores de presión

Las medidas de presión en este proyecto no requieren de especial precisión, puesto que en todos los casos establecen un control de presencia que fácilmente podría ser sustituido por un final de carrera. No obstante, por cuestiones de espacio, no es viable la aplicación de estos interruptores. La principal ventaja de usar sensores de presión es la

27

posibilidad de expandir las tareas de monitorización en futuras revisiones del proyecto gracias a la realimentación que estos sensores puedan aportar.

De entre todos los sensores disponibles en el mercado se eligen los sensores Flexiforce, por presentar un gran número de ventajas para nuestro proyecto:

• Precio reducido • Tamaño mínimo de instalación • Simplicidad de lectura

Se trata de sensores resistivos que se pueden utilizar para medir presión o, simplemente, como botones sin elementos móviles o finales de carrera. Un simple divisor de tensión es todo el circuito necesario para poder medir la fuerza aplicada en el área del FSR.

Imagen 19: Sensor Flexiforce [7]

Tabla 2: Relación presión-resistencia para los sensores Flexiforce [7]

Finales de carrera

Debido al descubrimiento de los sensores Flexiforce, estos serán los utilizados como finales de carrera, normalizando así la lectura de sensores.

Sensor de presencia

Respetando la línea de los sensores utilizados hasta el momento, se utilizará una barrera óptica basada en una LDR y un LED. Este conjunto se situará de forma fija en la

28

posición de carga del revólver. Por tanto, el proceso de detección se realizará en la posición de reposo del ATC, rotando cada herramienta y realizando una lectura de la LDR. Este sistema aporta la ventaja de ser fácilmente ajustable por software al tratarse de una medida analógica que permitirá escoger el umbral de luz para cada herramienta. La segunda ventaja es que permite más flexibilidad para montar en el carrusel, cuyo diseño puede verse sometido a variaciones.

4.5 Requisitos de la unidad de control

Una vez conocidos los actuadores necesarios es posible generar las especificaciones de la unidad de control, que son los siguientes:

• Control PWM de 5 servomotores a 5V (pulsos entre 600 y 2000us) • Control de 3 motores DC de menos de 1A 12V • Lectura de 5 sensores resistivos de presión • Lectura de 1 sensor resistivo de luz • Control de hasta 3 semáforos de LEDs RGY • Comunicación por Bluetooth • Espacio suficiente para aplicación de control compatible con host CAM • Posibilidad de extensiones de comunicación • Posibilidad de conectar panel de control (LCD + botonera)

La unidad de control debe ser robusta y debe incorporar todos los elementos necesarios para poder conectar directamente todos los elementos sin necesidad de añadir ningún hardware intermedio. El sistema CNC estará conectado siempre a la red, pero debe de ser capaz de trabajar a 12V.

4.6 Diseño de la unidad de control

A partir de las especificaciones de la unidad se eligen los componentes necesarios para desarrollar la placa:

• El control PWM se realizará directamente desde el microcontrolador. • Para el control de los 3 motores DC será necesario un driver. • Los sensores de presión se medirán con un divisor de tensión desde el micro,

utilizando su ADC al igual que el sensor LDR. • El control de los LEDs será directo desde el microcontrolador. • Para la comunicación Bluetooth será necesario un módem BT. • Se deberá utilizar un microcontrolador de gran memoria para la aplicación

futura. • Como mínimo, la placa deberá disponer de dos puertos de 8 bits libres del

microcontrolador para poder conectar una pantalla LCD y una mínima botonera.

29

4.6.1 Requisitos y elección driver motores

Es necesario controlar, como mínimo, tres motores de corriente continua alimentados a 12V con un consumo inferior a 1A cada uno. El control debe ser bidireccional para el actuador lineal y para el motor de la fresadora, puesto que se espera que esta opción ayude a la extracción de la herramienta gracias a la estructura del anclaje. El motor del torno, por el contrario, sólo requiere una dirección, aunque no se descarta la posibilidad de la bidireccionalidad.

Frente a estas necesidades, el control electrónico parece el más adecuado descartando la utilización de relés. En la categoría de drivers de estas características aparece como predilecto el integrado L293, siendo éste un chip con cuatro medios puentes H. Permite, por tanto, controlar dos motores de hasta 36V de forma bidireccional y con protección térmica. Se escoge el modelo L293DD por tratarse del encapsulado SO e incluir los diodos de “clamping” necesarios, ahorrando espacio en el diseño final; por el contrario este modelo soporta menos corriente por canal (600 - 1200mA por canal).

Imagen 20: Driver para motores DC L293DD

Se instalarán un total de dos L293DD en la placa de control, puesto que uno será necesario para los motores de fresado y de desplazamiento del revólver. El segundo driver permitirá realizar un control bidireccional del torno y añadir un motor DC extra en caso de necesitarlo o incluso doblar la potencia de un motor en caso de necesidad.

4.6.2 Requisitos y elección módem BT

Para permitir la comunicación Bluetooth del dispositivo se escoge un módem de la marca finlandesa Bluegiga. De entre el catálogo disponible se elige el WT-11 por tratarse de la solución integrada más simple. La ventaja principal de los módulos de Bluegiga es la transparencia que se consigue para incorporar comunicación Bluetooth a los diseños electrónicos, puesto que sus productos incorporan todos los elementos necesarios, desde la antena hasta el firmware iWrap que permite una rápida configuración del modulo vía USART.

30

Imagen 21: Módem Bluetooth WT11 [8]

El WT-11 es un módem BT de clase 2 con una potencia de transmisión de hasta 17dBm (hasta 100m).

La alimentación necesaria es de 3.3V y posee un consumo en operación de 170mA.

4.6.3 Requisitos y elección extras

Para dotar a la placa de control de más versatilidad se añadirán los siguientes elementos al diseño:

• Sensor de temperatura • ADC de alta resolución • EEPROM externa de gran tamaño • Interfaz USB mediante chip FTDI para depuración

Para normalizar el diseño, la distribución de señales en conectores se realizará en forma de módulos independientes e intercambiables. Esto, junto con el puente H que queda disponible, permitirá la adición de un conjunto extra de backup. Cada conjunto de señales incluirá:

• 1 Motor bidireccional • 1 semáforo de leds • entradas analógicas

Imagen 22: Señales estándar para cada conector

1 23 45 67 89 1011 12

P9

MOTOR1B

FSR1FSR2

LDR1LED_L_GREENLED_L_YELLOW

VCC_5

MOTOR1A

LED_L_RED

31

Además, se añadirá un conector extra para señales I/O generales como, por ejemplo, un final de carrera que detecte si el sistema ATC se encuentra debidamente cerrado, o una barrera óptica, si fuese necesario. Las señales de control para los servomotores serán independientes, puesto que éstos ya se distribuyen con su cableado y conector.

Imagen 23: Señales genéricas para extensiones

También se preverá un conector especial I2C que permitirá en un futuro añadir más módulos al sistema de forma sencilla. Como principal aplicación se propone la comunicación con un módulo de control de un motor de mayor potencia paa el uso del útil.

4.6.4 Requisitos y elección uC

Una vez expuestas las necesidades y los componentes, es posible dimensionar el microcontrolador necesario para gestionar le conjunto IO:

• 12 salidas digitales para el control de los motores. • 12 salidas digitales para el control de LEDs. • 12 entradas analógicas para la lectura de los sensores. • 3 entradas/salidas digitales para propósitos generales. • 3entradas analógicas para propósitos generales. • 5 salidas PWM. • 8 IO digitales para el control de LCD y botones • 1 USART (comunicación USB). • Bus I2C (comunicación externa + ADC 18 bits). • Bus SPI (memoria externa EEPROM). • Gran memoria de programa.

Esto hace un total de:

• 35 IO digitales • 15 entradas analógicas • 5 salidas PWM

MASTER_SIGNALD_CLOSED_START

D_BTN_1PULL_DOWN

PULLUP

1 23 45 67 89 1011 12

P17VCC_5

GND

32

De entre los productos que cumplen estos requisitos se escoge el ATMega2560, un microcontrolador AVR de la casa Atmel con las siguientes especificaciones [9]:

• 4Kbytes de EEPROM • 8Kbytes de SRAM • 256Kbytes de FLASH con sección para bootloader • 4 contadores de 8 bits + 4 de 16 bits • 16 canales PWM • 16 canales ADC de 10bits • Cuatro USART • SPI • I2C • Watchdog • 86 IO digitales

4.6.5 Elección de un comicro

Por diversas razones se ha decidido añadir al sistema un comicro que liberará de carga al micro principal reforzando la dedicación a la aplicación de fresado para la que se diseña. De esta manera el comicro se encargará de gestionar las comunicaciones Bluetooth y determinar en situaciones de operación que mensajes debe recibir el micro principal y cuando. Con esto se pretende conseguir menor vulnerabilidad de la aplicación principal frente a incorrectas gestiones por parte del operario. Los dos mircrocontroladres se comunicarán mediante I2C siendo el comicro el esclavo. Esta configuración también se realiza en previsión de una futura fase de este proyecto que podría incluir el desarrollo de un bootloader por I2C para el micro principal, de modo que desde cualquier dispositivo Android con Bluetooth e Internet se podría descargar la aplicación a la placa y sería el comicro quién programaría al micro principal y a todos aquellos que estuviera conectados al bus I2C. Esto no obstante se decidirá en el futuro.

La elección del comicro se ha basado en el Atmega328. Se escoge este microcontrolador por tratarse de una solución bien conocida con espacio de memoria suficiente para la aplicación “puente” y con asegurada compatibilidad con el micro principal.

4.6.6 Panel de Control

El panel de control se realizará como una herramienta de acceso rápido a la configuración del sistema pues a diferencia de la comunicación Bluetooth este directamente comunicará con el microcontrolador principal.

Se tratará de un panel LCD 16x2 con comunicación en modo 4 bits junto con cuatro botones con circuito antibouncing y funcionalidades estándar:

• Escape • Enter • Más

33

• Menos

4.6.7 Etapa de alimentación

El sistema se alimentará a 12 V, la tensión necesaria para los motores de continua. Para el circuito de control serán necesarios 5 V que se obtendrán de un regulador de tensión. Para este proyecto se ha escogido el modelo MIC29300-5.0WU de Micrel en base a los resultados obtenidos en el capítulo de cálculos. Este regulador puede proporcionar 3 A con picos de hasta 5 A. Para el modulo Bluetooth será necesario añadir un regulador de 3.3 V, en este caso el LP298 de National Semiconducor.

34

5 Diseño y fabricación

5.1 Herramientas utilizadas para la elaboración de este proyecto

Este proyecto abarca diversas áreas de la ingeniería y se ha apoyado en varias herramientas de software para su desarrollo.

5.1.1 Arduino IDE

Se trata del entorno de desarrollo centrado en la placa de prototipado más popular en Internet actualmente, Arduino [10]. El entorno en si no se utilizará de froma directa aunque si el conjunto de librerías que respaldan este proyecto de licencia libre. La diferencia de este entorno en el desarrollo de aplicaciones para la familia de microcontroladores AVR de Atmel con otros IDEs es prinicipalmente toda la comunidad que respalda el proyecto en la red. Gracias a todas las soluciones presentes se reduce el tiempo de diseño de software gracias al encapsulado en librerías y clases de prácticamente cualquier función de los uC soportados.

5.1.2 Eclipse

Eclipse es un entorno de desarrollo software gratuito muy potente gracias al gran número de extensiones que existen para utilizarlo en la programación de prácticamente todos los lenguajes actuales.

En este proyecto se utilizará este IDE para el desarrolo de las aplicaciones en C++ de los microcontroladores utilizados así como su versión JAVA para el desarrollo de la aplicación Android que correra en el dispositivo móvil.

5.1.3 WinAVR

Esta aplicación permite descargar los ficheros .hex generados mediante Eclipse a los uCs. Se integra en el entorno de desarrollo Eclipse facilitando así el test de las aplicaciones.

5.1.4 Android SDK

El kit de desarrollo de software para Android es un element necesario para poder trabajar en la programación de las aplicaciones móviles. Constituye todo el conjunto de paquetes necesarios para cualquier release del sistema operativo.

5.1.5 Altium Designer

El diseño del circuito de control se ha llevado a cabo con esta herramienta al tratarse de un software extremadamente eficiente para la creación de placas electrónicas. Su interfaz de usuario es extremadamente intuitiva facilitando el diseño y reduciendo el tiempo gracias a todas las posibilidades que ofrece como sus excelentes algoritmos de autorouting.

35

5.1.6 Diseño de esquemáticos y variantes

El diseño se realiza mediante el software Altium Designer Release 10.

Para facilitar el trabajo y la revisión, el diseño se divide en cuatro hojas separando así el proyecto en bloques funcionales.

El primer plano incluye el bloque de control básico con todos los extras. Remarcar la inclusión de los conectores de programación ISP y de comunicaciones I2C. El control de las señales de habilitación de los drivers para motores se realiza mediante transistores. Por defecto los tres primeros puentes se encuentran habilitados mediante resistencias de pull-up mientras que el cuarto está deshabilitado. También se puede observar como los dos puentes del segundo driver pueden trabajar en paralelo gracias a los jumpers para tal efecto. También señalar que se añade un conector extra para otro servomotor.

El segundo plano incluye el circuito del comicro según datasheet junto con el módem Bluetooth y la etapa a 3.3 V. Puesto que el módem puede ofrecer muchas más funcionalidades que las previstas en este proyecto se han extraído todas sus señales para poder acceder a ellas en caso de querer desarrollar aplicaciones más exigentes con este dispositivo.

El tercer plano incluye el bloque de comunicación USB. Este bloque procede directamente de la documentación del chip FTDI y de los planos abiertos de la placa de prototipos Arduino Duemilanova [10].

Finalmente el cuarto plano recoge la configuración de los conectores. Todas las entradas/salidas de los microcontroladores no utilizadas así como sus USARTs libres se han extraído para hacerlas accesibles en caso de necesidad.

El diseño completo se distribuye en tres variantes de producto descritas a continuación. Para información más detallada del PnP consultar los apéndices.

• Low: Es la variante menos populada. Solo consta del micro principal con los componentes estrictamente necesarios para controlar servos, motores y sensores. El objetivo de esta variante es tener una placa de control automática para pruebas de actuadores o procesos automáticos.

• High: Es la variante principal que incluye además del control el bloque de comunicación Bluetooth. Esta variante es la diseñada para que se puedan realizar los test del sistema ATC.

• Prototype: Esta variante es la más populada y supone la unidad de control completa puesto que soporta la configuración por Bluetooth y la descarga de datos desde la aplicación CAM mediante una conexión USB.

Los esquemáticos completos se encuentran en el capítulo “Planos”.

36

5.1.7 Diseño del PCB

El diseño de la placa de circuito impreso se realizó directamente sobre Altium utilizando sus herramientas de ruteado. El diseño se realizo en cuatro capas siendo una de ellas plano de masa necesario para el correcto funcionamiento del módem Bluetooth y para la disipación de calor de los drivers y reguladores. Las dimensiones acordadas para la placa de control son de 150mm x 90mm.

A excepción de los conectores todos los componentes elegidos son SMD y se han emplazado en las caras superior e inferior. Se busca con esto conseguir mejor aprovechamiento del espacio y eficiencia además de facilitar el montaje automático en caso de requerir pequeñas series para próximas fases.

Varios footprints tuvieron que ser diseñados o modificados a mano por no existir en las librerías disponibles entre ellos los condensadores polarizados y el módem Bluetooth de Bluegiga.

Imagen 24: Captura de pantalla del diseño 3D de la placa de control mediante Altium Designer

5.2 Fabricación de los prototipos

5.2.1 Fabricación de prototipos del PCB

Al tratarse de un diseño complejo de PCB, la fabricación se encargo a Eurocircuits. Se fabricaron para tal efecto 4 placas con objetivos de desarrollo. El tiempo requerido para la producción fue de dos semanas.

5.2.2 PCB del Panel de Control

Esta placa fue directamente diseñada de forma manual sobre PCB debido a su simplicidad, es por ello que en esta memoria solo se incluye el esquemático de esta placa. Se trata de un circuito de dimensiones 90mm x 70mm de una cara que incluye el conector

37

para el panel LCD y cuatro botones cada uno con un circuito anti-rebote. El ataque fue mediante cloruro férrico. Entrega de componentes

Gracias a las herramientas de Altium Designer es posible comprobar la disponibilidad de los componentes en las tiendas online. Como único proveedor de componentes se escogió a RS online [11], a excepción de los conectores hembra IDC aéreos de 12 vías que tuvieron que pedirse a E.E.U.U. a la empresa Windford Engineering [12] por no encontrarse disponibles en Europa.

Para más información consultar la sección presupuesto.

5.2.3 Montaje de los prototipos

El montaje de los dos primeros prototipos (variantes Low y High) se realizó con la colaboración de un equipo profesional de rework y prototipado.

Posterior a su montaje las unidades de control superaron los siguientes test diseñados especialmente:

Test de visión

Una vez montadas las placas se sometieron a una estricta revisión con microscopio de soldaduras y polaridades

Test de cortocircuitos y continuidades

El equipo de montaje comprobó de forma manual y según procedimientos industriales la presencia de cortocircuitos y de continuidades abiertas.

Test funcional de entradas salidas

A la placa se le descargó una aplicación de test que permitió realizar un test lecturas de entradas y de activación de salidas.

Test de stress con cargas

Una última aplicación se descargó para verificar el funcionamiento tras largos periodos de activación. El test se realiza con cargas reales durante una hora durante la cual tres motores funcionan continuamente con cambios de sentido y junto a operaciones de los servomotores.

Una vez finalizados los test las unidades son barnizadas para protegerlas de la suciedad.

5.3 Desarrollo software

Todo el desarrollo de software para los microcontroladores de la placa de control se ha basado en la estructura diseñada para el sistema Arduino en el que la ejecución del código se divide en dos funiones principales: setup y loop. La primera de ellas se ejecuta

38

una única vez al inicarse el microcontrolador mientras que la función loop se ejecuta indefinidamente. Esto se corresponde a la estructura básica de programación con una función while(1).

5.3.1 FKT IO

El objetivo de esta aplicación es el de gobernar las entradas y salidas de la placa de control mediante un código simple. Para este test se utiliza la USART 0 del ATMega2560 a modo de puerto de comunicaciones. Es necesaria la ayuda de un hardware USB externo que permita la interconexión con el PC (el mismo circuito USB que se monta en la variante Prototype en un PCB independiente).

El modo de trabajo es muy simple y está basado en un sistema de pregunta respuesta en el que se envía un comando a través de una aplicación terminal del PC y se recibe un comando en contestación. En el caso de lectura de entradas esta contestación será el valor leído y en el caso de una activación de salida se esperará una respuesta que permita asegurar la recepción correcta del comando.

El objetivo de este test es comprobar la integridad de la placa y de sus componentes verificando por un lado la lectura de los niveles de entrada que se forzarán a un valor deseado y por el otro la circuitería de salida que deberá activar las cargas conectadas.

Para completar el test se ha creado un único conjunto de cargas reales y sensores que podrán conectarse a cada puerto de la placa aprovechando así el diseño común de los conectores. Este incluye un motor DC, una LDR, un LED corriente, un LED doble y dos FSR, más un servomotor que se conecta independientemente.

5.3.2 Heavy Duty

Esta aplicación se diseña para ser ejecutada con la placa fabricada ya montada en el sistema final o con todas las cargas reales conectadas al mismo tiempo.

A diferencia del test IO este programa está diseñado para trabajar sin comunicación con el PC, solo debe ejecutar un recorrido de ida y vuelta de forma continua. Este recorrido tiene su inicio en la esquina inferior derecha de la superficie de trabajo y el final en la esquina opuesta. Durante todo el desplazamiento la herramienta está en funcionamiento.

Este test busca comprobar el funcionamiento en modo continuo de la placa de control para asegurar un correcto funcionamiento de los componentes en condiciones de trabajo.

La ventaja de utilizar diferentes etapas de test en lugar de utilizar la aplicación final reside en la facilidad para diagnosticar la raíz del problema sin tener que recurrir a otras herramientas.

5.3.3 Aplicación de Configuración y Control Manual

La aplicación final que este proyecto desarrolla es una simple interfaz de configuración que permite modificar los valores de la EEPROM que posteriormente definirán el funcionamiento del sistema. Esta configuración se podrá realizar tanto mediante el uso del panel de control físico diseñado o mediante el uso de un dispositivo

39

móvil con SO Android. El uso de ambos podrá ser simultaneo a excepción de los periodos en los que una función en concreto se este utilizando. Para los propósitos de este proyecto la rutina de configuración esta planteada para leer, controlar y configurar los siguientes elementos:

• Tres servomotores: permite mover y guardar hasta 7 posiciones para cada uno.

• Tres motores: permite girar en ambos sentidos con realimentación de las FSRs.

• Doce LEDs: permite desactivar su uso y los utiliza para señalizar el estado de configuración.

• Tres sensores LDR: Uno por conector, más uno general. Permite realizar lecturas y almacenar el nivel general de luz. Permite guardar niveles umbral para cada uno de ellos.

• Seis sensores de presión: Permite realizar lecturas.

Aplicación principal

La aplicación principal se encargará de manejar los datos almacenados en EEPROM que se prevé serán utilizados en el programa CAM. También es la encargada de manejar los actuadores en las opciones de control manual.

Este conjunto de funciones permitirán al usuario final realizar la comprobación del sistema y calibrar su funcionamiento para la aplicación posterior (siempre que se respete la zona de EEPROM).

La gestión de estas funciones se realizará mediante el panel de control manual o mediante los mensajes recibidos desde el dispositivo Android previamente filtrados por el comicro. La aplicación en este último caso solo deberá gestionar los mensajes que reciba del esclavo I2C (el comicro) y en función de ellos decidir que función realizar y con que valores.

El panel de control solo se ha instalado como solución de emergencia para la resolución de problemas, es por ello por lo que su funcionamiento se controla desde la aplicación principal, esto puede penalizar los tiempos de trabajo del sistema final por la necesidad de añadir un sistema de polling para determinar cuando se utiliza el teclado, o bien por la inclusión de una rutina de atención a la interrupción. No obstante de esta forma se asegura un control robusto sobre la aplicación principal.

Para el sistema de menú que utiliza el panel de control se ha creado una estructura de datos que conforma cada elemeno del menú. Esta estructura se presenta de forma gráfica a continuación:

40

Imagen 25: Estructura Visual del Menú.

Como se puede observar cada opción del menú se compone de diversos elementos:

• El índice de la opción, que la situa en el array. • El título, que indica el nivel de la opción. • El nombre de la opción, con fines descriptivos. • El índice de las opciones de igual jerarquía anterior y siguiente. • El índice de la opción de jerarquía superior. • El índice, si existe, de la opción de jerarquía inferior. • El nombre, si existe, de la función que esa opción debe ejecutar.

typedef struct{ int nmenu; String title; String text; int menuback; int menuenter; int menuplus; int menuminus; void (*PtrFuncSel)();

}menu;

Código 1: Estructura del menú.

De esta forma la gestión del menú se simplifica al cargar la opción correspondiente según la tecla presionada, con la excepción de las opciones finales que deben ejecutar una función específica, en ese caso el índice de la opción para la tecla Enter es 33 y el

41

programa en lugar de cargar el menú ejecuta la función que señala el puntero de la estructura.

El menú completo de muestra a continuación:

Imagen 26: Diagrama del menú de configuración

Las funciones de lecturas y escritura de EEPROM, así como las de control de servomotores, motores DC, conversor AD y otras se han basado en librerias abiertas sobretodo de la comunidad Arduino (la mayoría modificadas para este proyecto) así como librerías propias del autor. Las clases presentes en estas librerias no se muestran en este documento al entenderse que el lector interesado podrà recurrir a los medios digitales.

Aplicación Comicro

El comicro se planteó como una solución para asegurar una menor carga del micro principal durante su operación y a la vez como un sistema de seguridad de filtrado de los mensajes recibidos por Bluetooth. La tarea principal debe ser por tanto la de recibir cualquier comunicación entrante y decidir si el micro principal debe o no atenderla y cuando. Además deberá formatear los datos para poder enviar a través del bus I2C.

42

Otra tarea de la que se debe ocupar es de reclamar los datos que se pidan desde la aplicación Android al micro principal cuando sea necesario (y seguro) y formatearlos posteriormente como JSON para poder ser correctamente tratados por la aplicación. JSON (JavaScript Object Notation) no es más que un formato ligero para el intercambio de datos que consiste en una cadena de caracteres que de por si constituyen un array. Es muy popular sobretodo para la descarga de información desde Internet, sobretodo cuando se quiere prescindir del XML. El lenguaje Java ya incorpora herramientas para recuperar los datos necesarios de una forma transparente y de esta manera se elimina la necesidad de enviar dato por dato con su correspondiente gestión de los mensajes. Así pues las tareas a realizar por el comicro quedan descritas en la siguiente flowchart:

Imagen 27: Flowchart de la aplicación del comicro

Se han utilizado en esta aplicación las librerías Amarino [13] que permiten establecer de una forma fácil la comunicación Bluetooth entre un microcontrolador Atmel y un dispositivo Android. Estas librerías poseen las funciones de inicalización que incluyen el handshake así como las tareas de envio y recepción que permiten al programador reducir el tiempo de desarrollo.

43

Aplicación Android

La aplicación Android deberá mostrar una interfaz amigable al usuario y establecerá comunicación con el comicro para el intercambio de datos, encargándose de procesar los JSON recibidos para mostrarlos por pantalla.

Al tratarse de una aplicación puramente software se omitirá la descripción de este código (presente como apéndice) al entenderse que la implicación de este apartado con la línea general del proyecto es mínima en comparación con toda la información que debería incluirse para facilitar al lector un correcto entendimiento del programa, teniendo además en cuenta que la programación basada en Java no es objeto de estudio en el la ingeniería que nos ocupa.

Como muestra del programa se añaden unas capturas de pantalla:

Imagen 28: Menú de configuración de la aplicación Android

Imagen 29: Configuración de las posiciones del servo 1

44

Todas las pantallas se han diseñado en XML optimizando las presentaciones para ambas orientaciones.

Imagen 30: Menú de control manual (izquierda) y Opción de configuración de los niveles de luz

45

6 Cálculos

6.1 Consumo total de la unidad de Control

Dispositivo Reposo Operación Motor 70mA 200mA (sin regular) Servomotor 3mA 600mA (típico) Motor driver 60mA 44mA ATmega2560 NA 14mA ATmega328 NA 7mA FTDI chip NA 15mA BT modem 1.5mA 150mA (reg. 3.3V) Temp sensor NA 1mA 18 bit A/D 0.5uA 190uA EEPROM 2uA 5mA LCD panel 1.5mA 4mA LCD backlight 0 120mA

Tabla 3: Consumo de los componentes utilizados en el diseño

6.1.1 Peor caso 5V

El pero caso para dimensionar el circuito de alimentación de %v incluye las siguientes condiciones:

• Sensores resistivos en cortocircuito reduciendo la resistencia total de las 12 redes de sensado a 10K.

o IsT�12 � Is � 12� 5V

10KΩ� 12 � 0.5�� 6��

• Variante con los dos microcontroladores en funcionamiento.

o Imic = 14mA + 7mA = 21mA

• Módem Bluetooth en modo TX, máximo consumo limitado por el regulador de 3.3V.

o IBT = 150mA

• Estado en acceso a EEPROM externa.

o IEEPROM = 5mA

• Entrada lógica a nivel bajo de los drivers (peor caso).

o Idr = 4 · 60mA = 240mA (Cuatro motores activos)

• Tres servomotores en rotación (ejes).

o Iserv = 3 · 600mA + 2 · 3mA = 1806mA

• Sensor de temperatura en conversión.

o Itemp = 1mA

• FTDI chip recibiendo datos.

o Iusb = 15mA

46

• Todos los LEDs activos

o Iled = 7 · 30mA = 210mA

• Panel de control conectado y todos los botones presionados

o IbutT�4 � Ibut � 4� 5V

10KΩ� 4 � 0.5�� 2��

• LCD panel activo con Backlight On

o ILCD = 4mA + 120mA = 124mA

Así que en el peor caso el regulador debe ser temporalmente capaz de entregar:

IT = IsT + Imic + IBT + IEEPROM + Idr + Iserv + Itemp + Iusb + Iled + IbutT + ILCD

IT = 6 + 21 + 150 + 5 + 240 + 1806 + 1 + 15 + 210 + 2 + 124

IT = 2580mA

Aunque el proceso deberá asegurar que esta condición nunca se de puesto que podría poner en peligro la integridad del PCB al tratarse de corrientes tan elevadas.

47

7 Planos

P1 Hoja 1 del esquemático




P5 Planos Panel de control

P6 PCB vistaTop

P7 PCB Top layer

P8 PCB Ground Layer

P9 PCB Inner Plane

P10 PCB Bottom Layer

P11 PCB Vista Bottom

P12 PCB Mechanical Layer (Eurocircuits)

8 Presupuesto

La información de costes que se presenta en este capítulo hace referencia al esbozo del sistema de fresado y al diseño y fabricación de la unidad de control y considera el desarrollo del proyecto como un encargo desde cliente externo.

El total de costes se ha divido en bloques según etapas de desarrollo.

No se incluyen costes de fabricación del sistema mecánico ni de accionamientos o sensores puesto que para la elaboración de este proyecto no se ha fabricado el prototipo de la fresadora.

8.1 Estudio y diseño

En este apartado se consideran todos los costes derivados de las reuniones con cliente para la recopilación de especificaciones y discusión de alternativas. Incluye también el diseño hardware de la unidad de control mediante software CAD y la revisión de los planos. También se incluye la fabricación del PCB.

Diseño HW &

PCB

Materiales Trabajadores

Parcial Total Tipo

Cantidad

(unidad)

Coste

(€/unit) Categoria Horas

Coste

(€/h)

Diseño HW 460,0 €

Reuniones con

cliente - - - Engineer 4 30 120,0 €

HW spec.

Documento - - -

Junior

Engineer 2 20 40,0 €

Schematics

design - - -

Junior

Engineer 6,5 20 130,0 €

Revision

esquemáticos - - - Engineer 1,5 30 45,0 €

Diseño PCB - - - Junior


Revisión PCB - - - Engineer 1,5 30 45,0 €

Fabricación PCB 107,3 €

PCB 4 layer PCB 2 45,18 Outsource - - 90,4 €

Otros Gastos de

gestión 1 16,94 Outsource - - 16,9 €

PCB panel de

control Atacado 0,5 25,64

Laboratory

Technician 1 8 20,8 €

Diseño HW & PCB 567,3 €

61

8.2 Componentes

El listado de componentes se presenta a continuación junto con los precios. Las cantidades están ajustadas a las necesidades del proyecto y a los mínimos de adquisición fijados por el proveedor:

Ref Prov. Qty. Descripción

Precio

Unidad Total

522-4992 5 15-bussed SMT resistor network,10K 0,516 € 2,58 €

727-4790 5 LDO Regulator Pos 5V 1A 1,102 € 5,51 €

666-4530 2 MCU 8-Bit ATmega RISC 256KB FL TQFP100 17,370 € 34,74 €

691-7500 5 0805 PTC Resettable Fuse, 200mA 0,434 € 2,17 €

714-0625 5 4-Channel Motor Driver 24V, SOIC20 3,430 € 17,15 €

669-6076 2 8-bit DST ADC,1 ch,4sps,MCP3421A0T-E/CH 2,910 € 5,82 €

721-7924 5 Anti-Surge Resistor, 0805, 0.25W,1%,150K 0,132 € 0,66 €

537-846 1 Bluetooth 2.1 Module with Class 1 RF 34,230 € 34,23 €

159-4685 3 C.I. de conversión de señal,LM335Z TO92 1,500 € 4,50 €

691-1161 10 Capacitor 0805 10uF 16V 0,372 € 3,72 €

684-3998 10 Capacitor Tantalum SMT 293D 20V 2.2uF 0,141 € 1,41 €

666-5662 1 Carbide PCB drill bit 1/8" shank 0.90mm 3,780 € 3,78 €

264-4258 25 Cond cerámico SMD 0805 C0G,22pF 50V 0,038 € 0,95 €

264-4450 25 Cond cerámico SMD 0805 Y5V,1uF 16V 0,094 € 2,35 €

264-4422 100 Cond cerámico SMD 0805 Z5U,0.1uF 50V 0,026 € 2,60 €

407-0025 5 Condensador de tántalo SMD TPS,22uF 16V 0,988 € 4,94 €

679-1049 50 CRCW0805 Resistor T/R 0.125W,1%,1M 0,044 € 2,20 €

679-1187 50 CRCW0805 Resistor T/R 0.125W,1%,27R 0,012 € 0,60 €

679-1207 50 CRCW0805 Resistor T/R 0.125W,1%,2K2 0,021 € 1,05 €

478-9505 10 Crystal SMD 16.000MHz HC49S-SMD 0,439 € 4,39 €

629-0473 10 DIODE SMD GF1G 0,237 € 2,37 €

686-2258 5 EEPROM SPI 256KBit 5MHz SOIC8 1,868 € 9,34 €

435-541 1 Eurocard de doble cara,220x100mm 5,300 € 5,30 €

487-848 2 Hembra Aliment,PCB,2,1mm 5A 250V 2,500 € 5,00 €

720-0213 1 LCD, alphanumeric 16x2, STN, reflective 8,170 € 8,17 €

466-3908 40 LED chip transp 1206 verde KP-3216SGC 0,069 € 2,76 €

535-9111 5 LM335M Precision temperature sensor,SO8 1,068 € 5,34 €

738-0432 5 MCU 8-Bit AVR 32KB Flash 2.5/3.3/5V 3,200 € 16,00 €

725-0101 2 mm SMD sealed Trimmer Pot, 10K,25% 1,080 € 2,16 €

737-3005 10 NIC Components NAWU330M25V6.3X6.3LBF 0,264 € 2,64 €

661-0549 10 OP Amp Dual GP 16V/32V 8-Pin SOIC 0,130 € 1,30 €

734-6763 4 Pushbutton Switch,DP,on-mom,PCB term 1,460 € 5,84 €

652-0033 4 Regulador lineal tensión,LP2985AIM5-3.3 0,570 € 2,28 €

740-9072 50 SMD 0805 thick film resistor 10K 5% 0,014 € 0,70 €



740-9031 50 SMD 0805 thick film resistor 4K7 1% 0,016 € 0,80 €

671-0435 5 Trans MOSFET P-CH 20V 2A 3-Pin SuperSOT 0,636 € 3,18 €

406-580 2 USB to serial TTL level UART FT232RL 5,000 € 10,00 €

62

748-0866 3 WR-COM USB Connector B horizontal 1,070 € 3,21 €

Winford 6 Connector IDC 12 vias aereo 2.54mm 1,430 € 8,58 €

Total 231,82 €

Gestión 8,00 €

IVA 41,73 €

Suma 281,55 €

8.3 Fabricación de prototipos

La fabricación de los prototipos requiere un laboratorio y técnico especializado en soldadura SMD. En el precio por hora se incluye el coste de utilización del equipo necesario.

Como ya se especifico anteriormente cada unidad se testea completamente antes de enviarla a cliente.

Fabricación y

Test

Materiales Trabajadores

Parcial Total Tipo Cantdad (g)

Coste

(€/g) Categoria Horas

Coste

(€/h)

Fabricación prototipo 49,8 €

Revisión

documentación - - -

Laboratory

Technician 0,5 8 4,0 €

Colocación de

componentes

Flux y

pasta 10 0,868

Laboratory


Soldadura Estanyo 100 0,064 Laboratory


Barnizado Barniz 200 0,0136 Laboratory


Tests & validación 48,0 €

Inspección

óptica - - -

Laboratory


Short test - - - Laboratory


I/O test - - - Junior


FKT test - - - Junior


Fabricación y Test 97,8 €

63

8.4 Desarrollo de SW

Incluye el desarrollo de la aplicación de configuración para las tres unidades implicadas así como el desarrollo de las aplicaciones para el test de las unidades fabricadas.

Desarrollo Sw Trabajadores

Parcial Total Categoria Horas Coste (€/h)

Diseño Sw 150,0 €

Arquitectura Engineer 1 30 30,0 €

Desarrollo de código Junior


Aplicación Host

Android Engineer 2 30 60,0 €

SW Test 30,0 €

Aplicación test estrés Junior

Engineer 0,5 20 10

Aplicación test FKT Junior

Engineer 1 20 20

Desarrollo Sw 180,0 €

8.5 Generación de la documentación

Solo tareas de documentación

Documentación

de proyecto

Trabajadores

Parcial Total Categoría Horas Coste (€/h)

Documentación 160,0 €

Generación de

documentación Junior Engineer 3 20 60,0 €

Generación

planos Junior Engineer 4 20 80,0 €

Revisión

documentación Junior Engineer 1 20 20,0 €

Documentación de proyecto 160,0 €

8.6 Costes Globales del Proyecto

La suma total de costes se especifica en la siguiente tabla. Este precio incluye el desarrollo del proyecto así como la fabricación de dos prototipos de variantes High y Low completamente funcionales.

64

Componentes y materiales 281,55 €

Diseño Hw y fabricación PCB 567,30 €

Manufactura y Test 97,80 €

Diseño Software 180,00 €

Documentación de proyecto 160,00 €

Total project cost (two prototypes) 1.286,65 €

65

9 Conclusiones

El enfoque propuesto en este proyecto para el sistema de cambio automático de herramienta a resultado interesante desde diversos puntos de vista pero sobretodo para la concepción de un sistema de fresado compacto y original de buenas características para un uso esporádico no profesional.

Debe tenerse en cuenta que la estructura de fresadora propuesta abre una abanico de posibilidades más amplio que el expuesto aquí, dado que en este caso el proyecto se ha visto limitado por los objetivos de simplicidad y de economía al tratarse de una primera aproximación a lo que en futuras revisiones debe presentarse como una solución completa.

Partiendo de esta idea principal el desarrollo de la placa de control ha sido una tarea complicada por el número de restricciones propuestas en el planteamiento del proyecto. El propósito de dichas restricciones estaba bien claro y de esta manera pretendían facilitar el objetivo final para el que debe servir el sistema aquí descrito (la validación de la solución ATC y de anclaje), no obstante han apartado al diseño completamente de las pautas generales para este tipo de máquinas en las que predominan los motores paso a paso como accionamientos principales y donde el útil fresador no se ve limitado por una alimentación en corriente continua de baja tensión.

A pesar de estas diferencias se ha conseguido cumplir con las especificaciones, y lo que es más importante, producir una placa de control con un alto grado de polivalencia gracias a detalles como las variantes de diseño, las funcionalidades añadidas, y la “normalización” de las señales de los conectores. Tanto es así que el producto de este proyecto ya se encuentra hoy en día en otros dispositivos.

La capacidad del sistema se ha podido demostrar con la aplicación de configuración, requeriendo esta una distribución de software completa para dos microcontroladores y un dispositivo Android genérico con Bluetooth. Cabe remarcar el uso de estas dos tecnologías (tanto el Bluetooth como el uso de Smartphones como paneles de control) dentro del proyecto para dotar al producto de capacidades innovadoras dentro las opciones presentes en el mercado.

Como conclusión final se puede afirmar que se han conseguido las metas propuestas para este trabajo de forma satisfactoria, pero además se han asentado las bases para un desarrollo más profundo de una fresadora por control numérico que en futuros estudios requerirá una mayor precisión en la elaboración de los planos mecánicos y un rediseño de la placa de control en base a los resultados de las pruebas que se lleven a cabo con el sistema ATC descrito, para producir finalmente una herramienta capaz de introducirse en el mercado.

66

Referencias

[1] US Army, Milling Machine Operations, 1988

[2] http://www.vortechcnc.com/accessories.html

[3] http://mfgnewsweb.com/archives/general_editorials/jan06/DMG_ultra.htm

[4] http://www.hitecrcd.com/

[5] http://www.tridenteng.co.uk/

[6] http://www.mfacomodrills.com/

[7] http://www.tekscan.com/flexiforce.html

[8] http://www.bluegiga.com/home

[9] http://www.atmel.com/devices/atmega2560.aspx

[10] http://www.atmel.com/devices/atmega2560.aspx

[11] http://es.rs-online.com/web/

[12] http://www.winfordeng.com/

[13] http://www.amarino-toolkit.net/

67

Apéndice A: Código Aplicación de Configuración (Eclipse IDE)

/* // Created 25/02/2012 // by Jorge Hermoso <[email protected]> // for XXXXXXXXX.com and URV */ #include "CNC.h" typedef struct{ //Esructura para el menú, consultar memoria para más información int nmenu; String title; String text; int menuback; int menuenter; int menuplus; int menuminus; void (*PtrFuncSel)(); }menu; const int Enter = 78; const int Back = 38; const int Plus = 12; const int Minus = 13; //Mensajes display-------------------------------------- const String twelcome = "CNC v02"; const String tenter = "Pulse Enter"; const String tautoma = "Ini Work"; const String tmenu = "Menu"; const String tconfig = "Configuracion"; const String tBT = "Bluetooth"; const String tmanual = "Ctrl Manual"; const String tservo1 = "Servo 1"; const String tservo2 = "Servo 2"; const String tservo3 = "Servo 3"; const String tposicion = "Posicion"; const String tcarga = "Carga"; const String tsubir = "Subir"; const String tbajar = "Bajar"; const String tluz = "Niveles de luz"; const String tsup = "Sens Pres Up"; const String tsdown = "Sens Pres Down"; const String tosc1 = "Oscur 1"; const String tosc2 = "Oscur 2"; const String tosc3 = "Oscur 3"; const String tmotor1 = "Motor 1"; const String tmotor2 = "Motor 2"; const String tmotor3 = "Motor 3"; const String tON = "On"; const String tOFF = "Off"; const String tCargar = "Cargar"; const String tper1 = "Porcentaje inf 1"; const String tper2 = "Porcentaje inf 2"; const String tper3 = "Porcentaje inf 3"; const String tleds = "Estado Leds"; const menu Menus[] = { {0, "", "", NULL, NULL, NULL, NULL, NULL}, {1, tmenu, tconfig, 0, 4, 2, 21, NULL }, //Configuracion {2, tmenu, tmanual, 0, 13, 3, 1, NULL }, //Manual {3, tmenu, tBT, 0, 19, 21, 2, NULL }, //Bluetooth {4, tconfig, tservo1, 1, 33, 5, 22, servoconf}, //Configuracion S1 {5, tconfig, tservo2, 1, 33, 6, 4, servoconf}, //Configuracion S2

68

{6, tconfig, tservo3, 1, 33, 7, 5, servoconf}, //Configuracion S3 {7, tconfig, tluz, 1, 33, 8, 6, lightconf}, //Ver nivel luz {8, tconfig, tsup, 1, 33, 9, 7, upconf}, //Configuracion L2 {9, tconfig, tsdown, 1, 33, 10, 8, downconf}, //Configuracion L3 {10,tconfig, tper1, 1, 33, 11, 9, perconf}, //Configurar umbrales {11,tconfig, tper2, 1, 33, 12, 10, perconf}, //Configurar umbrales {12,tconfig, tper3, 1, 33, 22, 11, perconf}, //Configurar umbrales {13, tmanual, tservo1, 2, 33, 14, 18, moveservo}, //S1 {14, tmanual, tservo2, 2, 33, 15, 13, moveservo}, //S2 {15, tmanual, tservo3, 2, 33, 16, 14, moveservo}, //S3 {16, tmanual, tmotor1, 2, 33, 17, 15, movemotor}, //M1 {17, tmanual, tmotor2, 2, 33, 18, 16, movemotor}, //M2 {18, tmanual, tmotor3, 2, 33, 13, 17, movemotor}, //M3 {19, tBT, tON, 3, 33, 20, 20, poscarga}, //BT ON {20, tBT, tOFF, 3, 33, 19, 19, NULL}, //BT OFF {21, tmenu, tCargar, 0, 33, 1, 3, poscarga}, //Inicialización {22, tconfig, tleds, 1, 33, 4, 12, enableleds} //Deshabilitar leds }; menu currentmenu = {0, "", "", NULL, 0, NULL, NULL, NULL}; //variable temporal para la carga del menu en uso int outmenu=0; bool flagleds = true; //----------------------------------------------------------- Servo servo[4]; mOtor motor[4]; int temp; //variable para lectura temporal de EEPROM int posToSet = 0; //Variable para almacenar la posición a grabar int light[4]; int dark[4]; int sensPdown[4] = {9, A1, A4, 12}; //sensores de presion posicion A int sensPup[4] = {10, A2, A5, 13}; //sensores de presion posicion B int sens[4] = {8, A0, A3, A11}; //sensores de luz int pos[4][9] = { // array para almacenar

//las posiciones de los servos, {1,2,3,4,5,6,7,8,9}, //4 servos 9 posiciones para cada uno {10,11,12,13,14,15,16,17,18}, //permite tratar de la misma

//manera al servo del ATC {19,20,21,22,23,24,25,26,27}, //y a los servos de posicionamiento

//para los que se guardaran {28,29,30,31,32,33,34,35,36}}; //las posiciones críticas int memMaster = 37; //espacio de memoria para lectura

//analógica del conector global int per[4]= {20,20,20,20}; //umbrales por defecto int memper[4]= {38,39,40,41}; //espacios de memoria para los

//valoRes umbrales int giro[4] = {0,0,0,0}; //variable indice de posicion en el array

//de posiciones de servomotores int posini[4][7] = { // array con las posiciones iniciales de

//los servomotores {0,1,2,3,4,5,6}, {16, 26, 37, 49, 60, 72, 90}, {16, 26, 37, 49, 60, 72, 90}, {16, 26, 37, 49, 60, 72, 90}}; int mAster = A6; //pin lectura analógica global int tApa = 70; //PIN 70 AÑADIDO A PINS_ARDUINO EN C:\arduino-

//0022\hardware\arduino\cores\arduino

69

int tApaLow = 84; //pin para habilitación detección de tapa cerrada int sensorValue[4] = {0,0,0,0}; //v temporal para lectura analógica int sensorMaster = 0; //v temp para lectura de la

//entrada analógica global int sensorTapa = 0; //variable temporal para la

//lectura del estado de la tapa int green[4] = {34,23,26,31}; //salidas de los LEDs int red[4] = {35,24,27,32}; int yellow[4] = {33,22,25,30}; int flagini =0; //Flag que determina si puede empezar o no

//la aplicación de mecanizado int nservo = 1; //numero de servo en uso int npos = 0; //posicion inicial dentro

//del array LiquidCrystal lcd(79, 39, 40, 41, 82, 81); //Creación del objeto LCD

//según librerias OpenSource //----------------------------------------------------------------------- //----------------------------------------------------------------------- //----------------------------------------------------------------------- void setup() { lcd.begin(16,2); lcd.print("Inicializando..."); //motor[0].wire(1,2); //motor sin uso motor[1].wire(48,49); //creación motor para el desplazamiento del carrusel motor[2].wire(47,46); //creación motor del útil //motor[3].wire(45,44); //motor sin uso for (int hole=0; hole<=4; hole++) { for (int dir = 0; dir <= 6; dir++) { //loop para recuperar todas las posiciones de memoria temp = EEPROM.read(pos[hole][dir]); posini[hole][dir] = temp; } } servo[0].attach(9); //Creación de los servomotores servo[0].write(posini[1][0]); //Y situación en la posición inicial delay(1000); servo[1].attach(6); servo[1].write(posini[1][0]); delay(1000); servo[2].attach(7); servo[2].write(posini[2][0]); delay(1000); servo[3].attach(8); servo[3].write(posini[3][0]); delay(1000); for (int i=0; i<=3; i++) //Declaración de los pines de LEDs como salidas { pinMode(green[i], OUTPUT); pinMode(red[i], OUTPUT);

70

pinMode(yellow[i], OUTPUT); } pinMode(84, OUTPUT); //Declaración de salidas y entradas del sistema pinMode(80, OUTPUT); pinMode(4, OUTPUT); pinMode(tApa, INPUT); pinMode(19, INPUT); pinMode(18, INPUT); //Carga de datos de memoria---------------------------------------------- for (int hole=0; hole<=3; hole++) //recuperación de los datos

//almacenados en EEPROM { temp = EEPROM.read(memper[hole]); per[hole] = temp; } Wire.begin(1); //Inició de la comunicación I2C digitalWrite(tApaLow, LOW); //Habilitación señal de tapa cerrada delay(500); //esperar con tapa abierta for (int hole=0; hole<=3; hole++) //Iluminación LEDS rojos y amarillos para señalar configuración { onRed(hole); onYellow(hole); } delay(2000); if (digitalRead(tApa) == HIGH) panel(); //Si la señal de tapa abierta está activa se lanza else { //la rutina de configuración configuración lcd.clear(); //De lo contrario se borra el LCD y se apagan los leds offYellow(0); offYellow(1); offYellow(2); offYellow(3); } flagini = 1; //Una vez aquí se activa el flag que señaliza el inicio de operación onGreen(0); //LEDs en verde para señalar máquina activa onGreen(1); onGreen(2); onGreen(3); delay(1000); } void loop(){

71

// XXX Aplicación de trabajo } //----------------------------------------------------------------------- //-----------------------------------------------------------------------//-----------------FUNCIONES ESPECIFICAS--------------------------------- //----------------------------------------------------------------------- void onRed(int nhole) //Función que activa LED rojo { if (flagleds==true){ digitalWrite(red[nhole], HIGH); digitalWrite(green[nhole], LOW); } } void onGreen(int nhole) //Función que activa LED verde { if (flagleds==true){ digitalWrite(red[nhole], LOW); digitalWrite(green[nhole], HIGH); } } void offRed(int nhole) //Función que desactiva LED rojo { digitalWrite(red[nhole], LOW); digitalWrite(green[nhole], LOW); } void offGreen(int nhole) //Función que desactiva LED verde { digitalWrite(red[nhole], LOW); digitalWrite(green[nhole], LOW); } void onYellow(int nhole) //Función que activa LED amarillo { if (flagleds==true){ digitalWrite(yellow[nhole], LOW); } } void offYellow(int nhole) //Función que desactiva LED amarillo { digitalWrite(yellow[nhole], HIGH); } void motordown(int nhole) //mueve el motor en un sentido hasta activar FSR { motor[nhole].onCCW(); //bajar sensorValue[nhole] = analogRead(sensPdown[nhole]); if (nhole ==1) { //Si se trata del motor del útil solo moverlo durante 2 segundos motor[nhole].onCCW(); delay (2000); motor[nhole].off(); } else if (sensorValue[nhole] > 200) { delay (500); sensorValue[nhole] = analogRead(sensPdown[nhole]); if (sensorValue[nhole] > 200){ motor[nhole].off(); } }

72

else { motor[nhole].onCCW(); //bajar } } void motorup(int nhole) //mueve el motor en otro sentido hasta activar FSR { motor[nhole].onCW(); sensorValue[nhole] = analogRead(sensPup[nhole]); if (nhole ==1) { //Si se trata del motor del útil solo moverlo durante 2 segundos motor[nhole].onCW(); delay (2000); motor[nhole].off(); } else if (sensorValue[nhole] > 200){ delay (500); sensorValue[nhole] = analogRead(sensPup[nhole]); if (sensorValue[nhole] > 150){ motor[nhole].off(); } } else { // turn LED on: motor[nhole].onCW(); } } void panel() //Función que gestiona el menu LCD e incluye menu BT { pinMode(Enter, INPUT); pinMode(Back, INPUT); pinMode(Plus, INPUT); pinMode(Minus, INPUT); offRed(0); offGreen(0); offYellow(0); offRed(1); offGreen(1); offYellow(1); offRed(2); offGreen(2); offYellow(2); offRed(3); offGreen(3); offYellow(3); int tecla=0; //Rutina inicial Si pulsa enter continuamos fshownumber(); while (outmenu!=1){ //flag que determina cuando se sale del menu //delay(800); tecla = teclapulsada(); switch(tecla){ case 1: //Enter menuenter(currentmenu.menuenter); //cargamos el menu elegido

73

break; //si se pulsa la tecla enter puede querer //cargar una aplicación case 2: //Back loadmenu(currentmenu.menuback); break; case 3: //Plus loadmenu(currentmenu.menuplus); break; case 4: //Minus loadmenu(currentmenu.menuminus); break; default: break; } tecla = 0; bt_config(); //Aquí es donde se lanza la rutina BT, mientras se espera tecla pulsada } //de esta manera los dos métodos de configuración son compatibles digitalWrite(4, LOW); //Cuando se sale del menu se apaga el LCD lcd.clear(); lcd.setCursor(0,0); lcd.print("Cerrar tapa..."); while (digitalRead(tApa) != LOW) //Se espera a que la señal de tapa cerrada esté inactiva { } } int teclapulsada(){ //Detecta si se ha pulsado una tecla, cual es y efecto antibounce int index = 0; if (digitalRead(Enter)== LOW){ while (digitalRead(Enter)== LOW){} delay(500); index =1; } else if (digitalRead(Back)== LOW){ while (digitalRead(Back)== LOW){} delay(500); index =2; } else if (digitalRead(Plus)== LOW){ while (digitalRead(Plus)== LOW){} delay(500); index =3; } else if (digitalRead(Minus)== LOW){ while(digitalRead(Plus)== LOW){} delay(500); index =4; } return index; } void menuenter(int menustep) //Rutina que carga el menu o la aplicación correspondiente { //Si el código es 33 significa que debe ejecutar la función del puntero

74

void (*PtrComando)(void); //Cargas las variables del menu que toca if (currentmenu.menuenter !=33) { currentmenu = Menus[menustep]; lcd.clear(); lcd.setCursor(0,0); lcd.print(currentmenu.title); lcd.setCursor(0,1); lcd.print(currentmenu.text); } else { PtrComando = currentmenu.PtrFuncSel; PtrComando(); } } void loadmenu(int menustep) //Rutina que carga el menu correspondiente { if (menustep == 0) { outmenu = 1; goto endloadmenu; } //Cargas las variables del menu que toca currentmenu = Menus[menustep]; lcd.clear(); lcd.setCursor(0,0); lcd.print(currentmenu.title); lcd.setCursor(0,1); lcd.print(currentmenu.text); endloadmenu: while (0) {} } void fshownumber() //Funcion que permite acceder al menu en un tiempo determinado { lcd.clear(); lcd.setCursor(0,0); lcd.print(twelcome); lcd.setCursor(0,1); lcd.print(tenter); for (int thisChar = 20; thisChar > 0; thisChar--) { lcd.setCursor(12,1); lcd.print(" "); lcd.setCursor(12,1); lcd.print(thisChar); delay(1000); if (digitalRead(Enter) == LOW) { delay (200); while (digitalRead(Enter)== LOW){} goto endloop; } } goto endmenu; endmenu: outmenu = 1;

75

endloop: digitalWrite(80, LOW); digitalWrite(4, HIGH); loadmenu(1); } void servoconf() //Función que permite la configuración de las posiciones de los servos { //El incremento de posiciones se acelera para reducir el tiempo int nser = 0; int npos = 0; int tecla = 0; int speed = 1; switch (currentmenu.nmenu) { case 4: nser=1; break; case 5: nser=2; break; case 6: nser=3; break; } lcd.clear(); lcd.setCursor(0,0); lcd.print("Servo "); lcd.print(nser); while (digitalRead(Back)!= LOW){ lcd.setCursor(0,1); lcd.print("Pos "); lcd.print(npos); lcd.print(" "); lcd.setCursor(8,1); lcd.print(posini[nser][npos]); lcd.print(" "); servo[nser].write(posini[nser][npos]); //Aumentar------------------------------------------------- if (digitalRead(Plus)== LOW){ speed = 20; while (digitalRead(Plus)== LOW){ if (posini[nser][npos] <= 180) posini[nser][npos] ++; //Se decrementa un paso la posición actual servo[nser].write(posini[nser][npos]); //actualiza la posición del servo lcd.setCursor(8,1); lcd.print(posini[nser][npos]); lcd.print(" "); delay (500/(speed/20)); speed += 10; } } //Disminuir--------------------------------------------------- if (digitalRead(Minus)== LOW){ speed = 20; while (digitalRead(Minus)== LOW){

76

if (posini[nser][npos] >= 3) posini[nser][npos] --; //Se decrementa un paso la posición actual servo[nser].write(posini[nser][npos]); //actualiza la posición del servo lcd.setCursor(8,1); lcd.print(posini[nser][npos]); lcd.print(" "); delay (500/(speed/20)); speed += 10; } } tecla = teclapulsada(); if (tecla== 1) { if (npos <= 9) { npos++; } else { lcd.clear(); lcd.setCursor(0,0); lcd.print("Guardar?"); tecla=teclapulsada(); while (tecla==0){ tecla=teclapulsada(); } if (tecla== 1) { lcd.clear(); lcd.setCursor(0,0); lcd.print("Guardando..."); for (int dir = 0; dir <= 6; dir++) { //loop para recuperar todas las posiciones de memoria EEPROM.write(pos[nser][dir], posini[nser][dir]); delay (500); } lcd.setCursor(0,1); lcd.print("Guard con exito!"); servo[nser].write(posini[nser][0]); delay (2000); goto salir; } else if (tecla == 2) { goto salir; } } } else if (tecla == 2) { goto salir; } } salir: loadmenu(currentmenu.menuback); } void lightconf() //Función que muestra por pantalla los niveles analógicos { //Y permite guardar el nivel del sensor global int tecla= 0; vuelta:

77

lcd.clear(); lcd.setCursor(0,0); lcd.print("H1 H2 H3 M"); while (digitalRead(Back)!= LOW) { sensorValue[1] = analogRead(sens[1]); delay(20); sensorValue[2] = analogRead(sens[2]); delay(20); sensorValue[3] = analogRead(sens[3]); delay(20); sensorMaster = analogRead(mAster); lcd.setCursor(0,1); lcd.print(" "); lcd.setCursor(0,1); lcd.print(sensorValue[1]); lcd.setCursor(4,1); lcd.print(sensorValue[2]); lcd.setCursor(8,1); lcd.print(sensorValue[3]); lcd.setCursor(12,1); lcd.print(sensorMaster); delay(200); if (teclapulsada()== 1) { lcd.clear(); lcd.setCursor(0,0); lcd.print("Guard Mastr min?"); lcd.setCursor(0,1); lcd.print(sensorMaster); tecla=teclapulsada(); while (tecla==0){ tecla=teclapulsada(); } if (tecla== 1) { lcd.clear(); lcd.setCursor(0,0); lcd.print("Guardando..."); EEPROM.write(memMaster, sensorMaster); delay (500); lcd.setCursor(0,1); lcd.print("Guard con exito!"); delay (1000); goto salir2; } else goto vuelta; } } while (digitalRead(Back)!= HIGH){} salir2: loadmenu(currentmenu.menuback); } void downconf() //Función que muestra por pantalla los niveles analógicos (sensores de //presión B) { lcd.clear(); lcd.setCursor(0,0); lcd.print("H1 H2 H3");

78

while (digitalRead(Back)!= LOW) { sensorValue[1] = analogRead(sensPdown[1]); delay(20); sensorValue[2] = analogRead(sensPdown[2]); delay(20); sensorValue[3] = analogRead(sensPdown[3]); lcd.setCursor(0,1); lcd.print(" "); lcd.setCursor(0,1); lcd.print(sensorValue[1]); lcd.setCursor(5,1); lcd.print(sensorValue[2]); lcd.setCursor(10,1); lcd.print(sensorValue[3]); delay(200); } while (digitalRead(Back)!= HIGH){} loadmenu(currentmenu.menuback); } void upconf() //Función que muestra por pantalla los niveles analógicos (sensores de //presión A) { lcd.clear(); lcd.setCursor(0,0); lcd.print("H1 H2 H3"); while (digitalRead(Back)!= LOW) { sensorValue[1] = analogRead(sensPup[1]); delay(20); sensorValue[2] = analogRead(sensPup[2]); delay(20); sensorValue[3] = analogRead(sensPup[3]); lcd.setCursor(0,1); lcd.print(" "); lcd.setCursor(0,1); lcd.print(sensorValue[1]); lcd.setCursor(5,1); lcd.print(sensorValue[2]); lcd.setCursor(10,1); lcd.print(sensorValue[3]); delay(200); } while (digitalRead(Back)!= HIGH){} loadmenu(currentmenu.menuback); } void moveservo() //Funcion que mueve el servo a traves de cada posicion seteada //sin posibilidad de variarla o guardarla { int nser = 0; int npos = 0; int tecla = 0; bool outfunc = false; switch (currentmenu.nmenu) { case 13: nser=1;

79

break; case 14: nser=2; break; case 15: nser=3; break; } lcd.clear(); lcd.setCursor(0,0); lcd.print("Servo "); lcd.print(nser); while (outfunc == false){ lcd.setCursor(0,1); lcd.print("Pos "); lcd.print(npos); lcd.print(" "); lcd.setCursor(8,1); lcd.print(posini[nser][npos]); lcd.print(" "); servo[nser].write(posini[nser][npos]); tecla = teclapulsada(); //Aumentar------------------------------------------------- if (tecla== 3) { if (npos <= 8) { npos++; servo[nser].write(posini[nser][npos]); //actualiza la posición del servo lcd.setCursor(8,1); lcd.print(posini[nser][npos]); lcd.print(" "); } } else if (tecla== 4) { if (npos >= 1) { npos--; servo[nser].write(posini[nser][npos]); //actualiza la posición del servo lcd.setCursor(8,1); lcd.print(posini[nser][npos]); lcd.print(" "); } } else if (tecla == 2) outfunc = true; } loadmenu(currentmenu.menuback); } void movemotor() //mueve los motores arriba y abajo hasta activar los finales de carrera //en el caso del útil simplemente gira de forma continua { int nmotor = 0; bool outfunc = false; int tecla = 0; switch (currentmenu.nmenu) { case 16: nmotor=1; break; case 17:

80

nmotor=2; break; case 18: nmotor=3; break; } lcd.clear(); lcd.setCursor(0,0); lcd.print("Motor "); lcd.print(nmotor); while (outfunc == false){ lcd.setCursor(0,1); lcd.print(" "); tecla = teclapulsada(); if (tecla == 4) { motordown(nmotor); lcd.setCursor(0,1); lcd.print("Bajando... "); } else if (tecla == 3) { motorup(nmotor); lcd.setCursor(0,1); lcd.print("Subiendo... "); } else if (tecla == 2) outfunc = true; } loadmenu(currentmenu.menuback); } void poscarga() //Situa a la fresadora en la posicion de inicio seguro { lcd.clear(); lcd.setCursor(0,0); lcd.print("Espere a que se "); lcd.setCursor(0,1); lcd.print("situe en posicion..."); servo[0].write(posini[1][0]); delay (1000); servo[1].write(posini[1][0]); delay (1000); servo[2].write(posini[2][0]); delay (1000); servo[3].write(posini[3][0]); delay (1000); motorup(1); motorup(2); motorup(3); lcd.clear(); } void perconf() //Función que permite configurar hasta 3 umbrales para las señales //analógicas { int nlight = 0; int tecla = 0; int speed = 1; switch (currentmenu.nmenu) { case 10: nlight=1; break; case 11: nlight=2;

81

break; case 12: nlight=3; break; } lcd.clear(); lcd.setCursor(0,0); lcd.print("Porcentaje inf "); lcd.print(nlight); while (digitalRead(Back)!= LOW){ lcd.setCursor(0,1); lcd.print("Porc. "); lcd.setCursor(6,1); lcd.print(per[nlight]); //Aumentar------------------------------------------------- if (digitalRead(Plus)== LOW){ speed = 20; while (digitalRead(Plus)== LOW){ if (per[nlight] <= 99) per[nlight] ++; //Se decrementa un paso la posición actual lcd.setCursor(6,1); lcd.print(per[nlight]); lcd.print(" "); delay (500/(speed/20)); speed += 10; } } //Disminuir--------------------------------------------------- if (digitalRead(Minus)== LOW){ speed = 20; while (digitalRead(Minus)== LOW){ if (per[nlight] >= 1) per[nlight] --; //Se decrementa un paso la posición actual lcd.setCursor(6,1); lcd.print(per[nlight]); lcd.print(" "); delay (500/(speed/20)); speed += 10; } } tecla = teclapulsada(); if (tecla== 1) { lcd.clear(); lcd.setCursor(0,0); lcd.print("Guardar?"); tecla=teclapulsada(); while (tecla==0){ tecla=teclapulsada(); } if (tecla== 1) { lcd.clear(); lcd.setCursor(0,0); lcd.print("Guardando..."); EEPROM.write(memper[nlight], per[nlight]); delay (500); lcd.setCursor(0,1); lcd.print("Guard con exito!"); goto lsalir; } else if (tecla == 2)

82

{ goto lsalir; } } else if (tecla == 2) goto lsalir; } lsalir: loadmenu(currentmenu.menuback); } bool outfunc = false; int tecla = 0; void enableleds() { //Función que permite deshabilitar el uso de los leds se señalización lcd.clear(); lcd.setCursor(0,0); lcd.print("Estado leds"); lcd.setCursor(0,1); lcd.print("Habilitados"); while (outfunc == false){ tecla = teclapulsada(); if (tecla == 1) { if (flagleds==false){ flagleds =true; lcd.setCursor(0,1); lcd.print("Habilitados "); } else { flagleds=false; lcd.setCursor(0,1); lcd.print("Deshabilitados"); } } else if (tecla == 2) outfunc = true; } loadmenu(currentmenu.menuback); } void bt_config() //Solicita mensaje I2C del esclavo y si está en la tabla ejecuta la //acción prevista { //Solo se han implementado algunas funciones como ejemplo byte code = 0; byte value = 1; int getvalue = 0; Wire.requestFrom(5, 2); // request 2 bytes from slave device #5 if (Wire.available()) { code = Wire.receive(); value = Wire.receive(); } else { } switch(code){ case 11: // sfini break; case 12: // sfss nservo = value; break; case 13: // sfsp npos = value;

83

break; case 14: // sfsd servo[nservo].write(value); break; case 15: // sfs EEPROM.write(pos[nservo][npos], value); posini[nservo][npos]=value; delay(500); break; case 16: // sfo break; case 17: // clini break; case 18: // cls break; case 19: // clo break; case 20: // ctini break; case 21: // ctsu EEPROM.write(memper[1], value); delay(500); per[1] = value; break; case 23: // ctsd EEPROM.write(memper[2], value); delay(500); per[2] = value; break; case 24: // ctst EEPROM.write(memper[3], value); delay(500); per[3] = value; break; case 25: // cto break; case 26: // sspu servo[1].write(posini[1][value]); break; case 27: // sspd servo[2].write(posini[2][value]); break; case 28: // sspt servo[3].write(posini[3][value]); break; case 29: // mini break; case 30: // mup motorup(value); break; case 31: // mdown motordown(value); break; case 32: // pini break; case 33: // po break; case 34: // sp poscarga(); break; case 35: // info break; case 36: // ss outmenu =1; break; case 37: // leds if (value==1) flagleds = true; else flagleds = false; break;

84

case 38: // closed break; case 40: //s1 Wire.beginTransmission(5); // transmit to device #5 Wire.send(posini[1][value-1]); // sends one byte Wire.endTransmission(); // stop transmitting break; case 41: //s2 Wire.beginTransmission(5); // transmit to device #5 Wire.send(posini[2][value-1]); // sends one byte Wire.endTransmission(); // stop transmitting break; case 42: //s3 Wire.beginTransmission(5); // transmit to device #5 Wire.send(posini[3][value-1]); // sends one byte Wire.endTransmission(); // stop transmitting break; case 43: //umb Wire.beginTransmission(5); // transmit to device #5 Wire.send(per[value]); // sends one byte Wire.endTransmission(); // stop transmitting break; case 44: //pres1 getvalue = analogRead(sensPup[value]); //sensPup[value]); Wire.beginTransmission(5); // transmit to device #5 Wire.send(getvalue/4); // sends one byte Wire.endTransmission(); // stop transmitting break; case 45: //pres2 getvalue = analogRead(sensPdown[value]); Wire.beginTransmission(5); // transmit to device #5 Wire.send(getvalue/4); // sends one byte Wire.endTransmission(); // stop transmitting break; case 46: //luz if (value==4) getvalue = analogRead(mAster); else getvalue = analogRead(sens[value]); Wire.beginTransmission(5); // transmit to device #5 Wire.send(getvalue/4); // sends one byte Wire.endTransmission(); // stop transmitting break; default: break; } }

85

Apéndice B: Código Aplicación Configuración Comicro (Arduino IDE)

#include <MeetAndroid.h>

#include <Wire.h>

#include <avr/io.h>

#include <avr/wdt.h>

MeetAndroid meetAndroid;

String message;

byte msend[2] = {0,0};

int mreceived = 0;

boolean flagi2cs = false;

boolean flagi2cr = false;

boolean sendflag = false;

int temp[10];

int s1 = 40;

int s2 = 41;

int s3 = 42;

int umb = 43;

int pres1 = 44;

int pres2 = 45;

int luz = 46;

int nsfini = 11;

int nsfss = 12;

int nsfsp = 13;

int nsfsd = 14;

int nsfs = 15;

int nsfo = 16;

int nclini = 17;

int ncls = 18;

int nclo = 19;

int nctini = 20;

int nctsu = 21;

int nctsd = 23;

int nctst = 24;

int ncto = 25;

int nsspu = 26;

int nsspd = 27;

86

int nsspt = 28;

int nmini = 29;

int nmup = 30;

int nmdown = 31;

int npini = 32;

int npo = 33;

int nsp = 34;

int ninfo = 35;

int nss = 36;

int nleds = 37;

int nclosed = 38;

String jname;

String jiden;

int jindex;

String jmeasure;

void setup()

{

Serial.begin(115200);

Wire.begin(5); // join i2c bus with address #2

Wire.onRequest(requestEvent); // register event

Wire.onReceive(receiveEvent); // register event

wdt_enable(WDTO_8S);

// register callback functions, which will be called when an associated event occurs.

meetAndroid.registerFunction(sfini , 'a');

meetAndroid.registerFunction(sfss , 'b');

meetAndroid.registerFunction(sfsp , 'c');

meetAndroid.registerFunction(sfsd , 'd');

meetAndroid.registerFunction(sfs , 'e');

meetAndroid.registerFunction(sfo , 'f');

meetAndroid.registerFunction(clini , 'g');

meetAndroid.registerFunction(cls , 'h');

meetAndroid.registerFunction(clo , 'i');

meetAndroid.registerFunction(ctini , 'j');

meetAndroid.registerFunction(ctsu , 'k');

meetAndroid.registerFunction(ctsd , 'l');

meetAndroid.registerFunction(ctst , 'm');

meetAndroid.registerFunction(cto , 'n');

87

meetAndroid.registerFunction(sspu , 'o');

meetAndroid.registerFunction(sspd , 'p');

meetAndroid.registerFunction(sspt , 'q');

meetAndroid.registerFunction(mini , 'r');

meetAndroid.registerFunction(mup , 's');

meetAndroid.registerFunction(mdown , 't');

meetAndroid.registerFunction(pini , 'u');

meetAndroid.registerFunction(po , 'v');

meetAndroid.registerFunction(sp , 'w');

meetAndroid.registerFunction(info , 'x');

meetAndroid.registerFunction(ss , 'y');

meetAndroid.registerFunction(leds , 'z');

meetAndroid.registerFunction(closed , 'A');

delay (2000);

}

void loop()

{

String messageK = "";

meetAndroid.receive(); // you need to keep this in your loop() to receive events

delay (150);

if (sendflag == true)

{

getValues(jmeasure);

messageK = json(jname, jiden, jindex);

meetAndroid.send(messageK);

}

wdt_reset();

}

//-----------------------------------------------------------------

//------------------------------------ Funciones i2c --------------

//-----------------------------------------------------------------

void requestEvent()

{

Wire.send(msend, 2); // respond with message of 6 bytes

// as expected by master

88

flagi2cs = true;

msend[0] = 0;

}

void receiveEvent(int howMany)

{

if(Wire.available()) // loop through all but the last

{

mreceived = Wire.receive(); // receive byte as an integer

flagi2cr = true;

}

//else mreceived = 515;

}

//-----------------------------------------------------------------

//------------------------------------ Funciones Registro BT ------

//---------------------------------------------------------------

void sfini (byte flag, byte numOfValues) {

}

void sfss (byte flag, byte numOfValues) {

int val = 1;

String mes = "";

val = meetAndroid.getInt();

jname = "servo";

jname = jname + val;

jiden = "p";

jindex = 7;

msend[0] = nsfss;

msend[1] = val;

delay (300);

if (val == 1) getValues("p1");

else if (val == 2) getValues("p2");

else if (val == 3) getValues("p3");

mes = json(jname, jiden, jindex);

meetAndroid.send(mes);

}

void sfsp (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

89

msend[1] = val;

msend[0] = nsfsp;

}

void sfsd (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

msend[1] = val;

msend[0] = nsfsd;

}

void sfs (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

msend[1] = val;

msend[0] = nsfs;

}

void sfo (byte flag, byte numOfValues) {

}

void clini (byte flag, byte numOfValues) {

jname = "light";

jiden = "l";

jindex = 4;

jmeasure = "luz";

sendflag = true;

}

void cls (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

msend[1] = val;

msend[0] = ncls;

}

void clo (byte flag, byte numOfValues) {

message = "";

sendflag = false;

}

void ctini (byte flag, byte numOfValues) {

String mes = "";

90

jname = "threshold";

jiden = "t";

jindex = 3;

getValues("umbrales");

mes = json(jname, jiden, jindex);

meetAndroid.send(mes);

}

void ctsu (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

msend[1] = val;

msend[0] = nctsu;

}

void ctsd (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

msend[1] = val;

msend[0] = nctsd;

}

void ctst (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

msend[1] = val;

msend[0] = nctst;

}

void cto (byte flag, byte numOfValues) {

message = "";

sendflag = false;

}

void sspu (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

msend[1] = val;

msend[0] = nsspu;

}

91

void sspd (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

msend[1] = val;

msend[0] = nsspd;

}

void sspt (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

msend[1] = val;

msend[0] = nsspt;

}

void mini (byte flag, byte numOfValues) {

}

void mup (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

msend[1] = val;

msend[0] = nmup;

}

void mdown (byte flag, byte numOfValues) {

int val;


msend[0] = 0;

msend[1] = val;

msend[0] = nmdown;

}

void pini (byte flag, byte numOfValues) {

int val;


if (val == 1){

jname = "pres";

jiden = "u";

jindex = 3;

jmeasure = "pres1";

92

}

else if (val == 2)

{

jname = "pres";

jiden = "d";

jindex = 3;

jmeasure = "pres2";

}

sendflag = true;

}

void po (byte flag, byte numOfValues) {

message = "";

sendflag = false;

}

void sp (byte flag, byte numOfValues) {

msend[0] = nsp;

}

void info (byte flag, byte numOfValues) {

}

void ss (byte flag, byte numOfValues) {

msend[0] = nss;

}

void leds (byte flag, byte numOfValues) {

int on;

on = meetAndroid.getInt();

msend[0] = 0;

msend[1] = flag;

msend[0] = nleds;

}

void closed (byte flag, byte numOfValues) {

}

//-----------------------------------------------------------------

//------------------------------------ Funciones publicas ---------

//-----------------------------------------------------------------

String json (String name, String iden, int index)

{

//"{\"light\": {\"l1\": \"212\", \"l2\": \"222\", \"l3\": \"233\", \"l4\": \"111\"}}"

String message;

String one = "{\"";

93

String two = "\": {";

String three = "\"";

String four = "";

String five = "\": \"";

String six = "\",";

String seven = "\"}}";

message = one + name; //\"light

message = message + two; //"\"light\":

for (int a = 0; a < index; a++) {

four = iden + (a+1);

message = message + three;

message = message + four;

message = message + five;

message = message + temp[a];

if (a == (index - 1)) {

message = message + seven;

}

else {

message = message + six;

}

}

return message;

}

void getValues (String name)

{

int index;

int code;

int esc;

if (name == "p1") {

index = 7;

code = s1;

esc = 1;

}

else if (name == "p2") {

index = 7;

code = s2;

esc = 1;

}

94

else if (name == "p3") {

index = 7;

code = s3;

esc = 1;

}

else if (name == "umbrales") {

index = 3;

code = umb;

esc = 1;

}

else if (name == "pres1") {

index = 3;

code = pres1;

esc = 4;

}

else if (name == "pres2") {

index = 3;

code = pres2;

esc = 4;

}

else if (name == "luz")

{

index = 4;

code = luz;

esc = 4;

}

else {

goto fin;

}

for (int i = 0; i<index; i++) {

temp[i] = geti2c(code, i + 1, esc);

}

fin:

int none = 0;

//return temp;

}

int geti2c(int code, int index, int esc)

{

int valor;

//SET code as response

95

msend[0] = code;

msend[1] = index;

flagi2cs = false;

//wait for request

//while ( flagi2cs != true)

//{}

delay (50);

//return response

flagi2cr = false;

//wait for request

//while ( flagi2cr != true)

//{}

//mreceived = random(250);

valor = esc * mreceived;

return valor;

}

96

Apéndice C: Código Test IO (Arduino IDE)

char type = '-';

char conf = '-';

char state = '-';

int num = 0;

void setup(){

Serial.begin(9600); // Empieza transmission a 9600 bps:

Serial.println('H', BYTE); // Envia H mayúscula como señal alive

}

void loop(){

if (Serial.available() > 0) {

// el mensaje consta de cuatro bytes (digital/analogico, //entrada/salida, alto/bajo, numero de pin)

type = Serial.read();

conf = Serial.read();

state = Serial.read();

num = Serial.read();

if (type == 'd') doDigital (conf, state, num);

else if (type == 'a') doAnalog (num);

}}

void doDigital(char inout, char estado, int numero) {

if (inout == 'o'){

pinMode(numero, OUTPUT);

if (estado == 'h') digitalWrite(numero, HIGH);

else if (estado == 'l') digitalWrite(numero, LOW);

Serial.println(inout, DEC);

}

if (inout == 'i'){

pinMode(numero, INPUT);

int valor = digitalRead(numero);

Serial.println(valor, DEC);

}}

void doAnalog(int numero) {

int sensor = analogRead(numero);

Serial.println(sensor, DEC);

}

97

Apéndice D: Código Test Heavy Duty (Eclipse IDE)

onYellow(1); onYellow(2); onYellow(3); delay (5000); onGreen(1); onGreen(2); onGreen(3); servo[1].write(0); //delay (500); servo[2].write(0); //delay (500); servo[3].write(0); delay (5000); servo[1].write(10); servo[2].write(10); servo[3].write(50); while (1) {

delay (5000); motor[1].onCW(); motor[2].onCW(); motor[3].onCW(); servo[1].write(160); delay (500); servo[2].write(160); delay (500); servo[3].write(80); delay (5000); motor[1].onCCW(); motor[2].onCCW(); motor[3].onCCW(); servo[1].write(10); delay (500); servo[2].write(10); delay (500); servo[3].write(50);

}

98

Apéndice E: Aplicación Android

package befaust.jorges119.eclipseBT;

import android.app.Activity;

import android.os.Bundle;

import android.view.Menu;

import android.view.MenuItem;

import at.abraxas.amarino.Amarino;

public class BTActivity extends Activity {

public static final String DEVICE_ADDRESS = "00:07:80:40:7D:07";

public static final char sfini= 'a'; //ConfServoInit

public static final char sfss= 'b'; //ConfServoSend servo

public static final char sfsp= 'c'; //ConfServoSend position

public static final char sfsd= 'd'; //ConfServoSend data

public static final char sfs= 'e'; //ConfServoSave

public static final char sfo= 'f'; //ConfServoOut

public static final char clini= 'g'; //ConflightInit

public static final char cls= 'h'; //ConflightSave

public static final char clo= 'i'; //ConflightOut

public static final char ctini= 'j'; //ConfthresholdInit

public static final char ctsu= 'k'; //ConfthresholdSend data 1

public static final char ctsd= 'l'; //ConfthresholdSend data 2

public static final char ctst= 'm'; //ConfthresholdSend data 3

public static final char cto= 'n'; //ConfthresholdOut

public static final char sspu= 'o'; //ServoSend pos 1

public static final char sspd= 'p'; //ServoSend pos 2

public static final char sspt= 'q'; //ServoSend pos 3

public static final char mini= 'r'; //MotorInit

public static final char mup= 's'; //MotorMotor n up

99

public static final char mdown= 't'; //MotorMotor n down

public static final char pini= 'u'; //PressureInit

public static final char po= 'v'; //PressureOut

public static final char sp= 'w'; //Start PositionInit

public static final char info= 'x'; //Software version/BatteryInit

public static final char ss= 'y'; //Start ShowInit

public static final char leds= 'z'; //LedsInit

public static boolean[] motors = {false, false, false, false};

public static int[][] servopos = new int[4][7];

public static int[] thresholds = {20, 20, 20, 20};

public static int[] lights = {0,0,0,0};

public static int master = 0;

public static boolean ledon = true;

public static int[][] pressures = {{0,0,0,0},{0,0,0,0},{0,0,0,0}};

public static String servo = "servo";

public static String light = "light";

public static String threshold = "threshold";

public static String motor = "motor";

public static String pressure = "pressure";

@Override

public boolean onCreateOptionsMenu(Menu menu) {

//menu.add(1, 1, 0, "Volver a Conectar");

menu.add(0, 1, 0, "Conectar").setIcon(android.R.drawable.stat_sys_data_bluetooth);

return super.onCreateOptionsMenu(menu);

}

@Override

public boolean onOptionsItemSelected(MenuItem item) {

switch (item.getItemId()) {

case 1:

Amarino.connect(getBaseContext(), DEVICE_ADDRESS);

}

100

return true;

}

}


import android.bluetooth.BluetoothAdapter;

import android.content.Context;

import android.content.Intent;


import android.os.Handler;

import android.view.Gravity;

import android.view.LayoutInflater;

import android.view.View;

import android.view.View.OnClickListener;

import android.view.ViewGroup;

import android.widget.AdapterView;

import android.widget.AdapterView.OnItemClickListener;

import android.widget.BaseAdapter;

import android.widget.Button;

import android.widget.GridView;

import android.widget.ImageView;

import android.widget.PopupWindow;

import android.widget.TextView;


public class HomeActivity extends BTActivity {

/** Called when the activity is first created. */

private static final String TAG = "servoControl";

//private static final String DEVICE_ADDRESS = "00:07:80:40:7D:07";//"00:07:80:99:56:B3";

private boolean popup_flag;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

if (savedInstanceState != null){

101

popup_flag = savedInstanceState.getBoolean("Popup_flag", false);

}

else popup_flag = false;

//setContentView(R.layout.main);

LayoutInflater inflater = getLayoutInflater();

GridView view = (GridView)inflater.inflate(R.layout.main, null);

view.setAdapter(new IconAdapter(this,

new IconItem ("Configuración", R.drawable.config_norm),

new IconItem ("Control Manual", R.drawable.man_norm),

//new IconItem ("Configuración", R.drawable.btn_config),

//new IconItem ("Configuración", R.drawable.btn_config),

new IconItem ("Sistema", R.drawable.system_norm),

new IconItem ("Show", R.drawable.show_norm)));

setContentView(view);

/*view.setOnItemClickListener(new OnItemClickListener()

{

public void onItemClick(AdapterView<?> parent,

View v, int position, long id)

{

Toast.makeText(getBaseContext(),

"pic" + (position + 1) + " selected",

Toast.LENGTH_SHORT).show();

}

}); */

view.setOnItemClickListener(new OnItemClickListener() {

public void onItemClick(AdapterView<?> parent, View v, int position, long id) {

//Intent i = new Intent(nclApp2.this, Screen2.class);

Intent myIntent = null;

if(position == 0){

myIntent = new Intent(v.getContext(), Configuration.class);

startActivity(myIntent);

}

if(position == 1){

myIntent = new Intent(v.getContext(), Manual.class);


}

if(position == 2){

102

myIntent = new Intent(v.getContext(), Sys.class);


}

if(position == 3){

Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, sp, 0);

try{

Thread.sleep(1000);

}

catch (Exception e){}

Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, ss, 0);

Amarino.disconnect(getBaseContext(), DEVICE_ADDRESS);

BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

if (!mBluetoothAdapter.isEnabled()) {

}else{

mBluetoothAdapter.disable();

}

finish();

}

}

});

/* ImageView image = (ImageView) findViewById(R.id.test_image);

image.setOnTouchListener(this); */

if (popup_flag == false) {

new Handler().postDelayed(new Runnable() {

public void run() {

showPopup();

popup_flag = true;

}

}, 100);

}

}

@Override

protected void onSaveInstanceState(Bundle outState) {

103

super.onSaveInstanceState(outState);

outState.putBoolean("Popup_flag", popup_flag);

}

@Override

protected void onStop() {

super.onStop();

// stop Amarino's background service, we don't need it any more

//Amarino.disconnect(this, DEVICE_ADDRESS);

}

public void showPopup(){

LayoutInflater inflater = (LayoutInflater)

getSystemService(Context.LAYOUT_INFLATER_SERVICE);

View layout = inflater.inflate(R.layout.welcome_popup, null, false);

Button but = (Button) layout.findViewById(R.id.widget41);

final PopupWindow pw = new PopupWindow(layout, 600, 400, true);

OnClickListener cancel_button_click_listener = new OnClickListener()

{

public void onClick(View v)

{

Amarino.connect(getBaseContext(), DEVICE_ADDRESS);

pw.dismiss();

}

};

but.setOnClickListener(cancel_button_click_listener);

pw.showAtLocation(findViewById(R.id.main), Gravity.CENTER, 0, 0);

}

/* @Override

public boolean onTouch(View v, MotionEvent e) {

// TODO Auto-generated method stub

float x = e.getX();

float y = e.getY();

104

switch (e.getActionMasked()) {

case MotionEvent.ACTION_DOWN:

if (x > 1 & x < 200 & y > 1 & y < 200) {

startActivity(new Intent(

this,

AndroidBitmap.class));

}

if (x > 1 & x < 200 & y > 200 & y < 400) {

//Toast.makeText(HomeActivity.this, "Otro " , Toast.LENGTH_SHORT).show();

startActivity(new Intent(

this,

Motor.class));

/// this is just another example of another set of coordinates.

}

break;

}

return true;

}*/

}

class IconItem {

final String name;

final int image;

IconItem(String name, int image) {

this.name = name;

this.image = image;

}

}

class IconAdapter extends BaseAdapter {

private final IconItem[] icons;

105

public IconAdapter(Context c, IconItem... icons) {

this.icons = icons;

}

public int getCount(){

return icons.length;

}

public Object getItem(int index){

return icons[index];

}

public long getItemId(int index){

return index;

}

private ViewGroup getViewGroup(View reuse, ViewGroup parent){

if(reuse instanceof ViewGroup) {

return (ViewGroup)reuse;

}

Context context = parent.getContext();

LayoutInflater inflater = LayoutInflater.from(context);

ViewGroup item = (ViewGroup)inflater.inflate(R.layout.menuone, null);

return item;

}

public View getView(int index, View reuse, ViewGroup parent) {

ViewGroup item = getViewGroup(reuse, parent);

TextView text = (TextView)item.findViewById(R.id.text);

ImageView but = (ImageView)item.findViewById(R.id.but1);

IconItem icon = icons[index];

text.setText(icon.name);

but.setImageResource(icon.image);

return item;

}

}

106










public class Configuration extends Activity {


@Override



/* if (savedInstanceState != null){


}

else popup_flag = false;*/



GridView view = (GridView)inflater.inflate(R.layout.conf, null);


new IconItem ("Posiciones", R.drawable.servosf_norm),

new IconItem ("Master Ligth", R.drawable.luz_norm),

//new IconItem ("Umbrales", R.drawable.umbr_norm),

new IconItem ("LEDs", R.drawable.led_norm)));






if(position == 0){

myIntent = new Intent(v.getContext(), ServoSel.class);

107

myIntent.putExtra("type", 1);

}

if(position == 1){

myIntent = new Intent(v.getContext(), MasterLight.class);

}

if(position == 2){

myIntent = new Intent(v.getContext(), Leds.class);

}

/* if(position == 3){

myIntent = new Intent(v.getContext(), Motor.class);

}*/


}

});

}

}






import at.abraxas.amarino.AmarinoIntent;

public class Leds extends BTActivity{

private Button onoff;

boolean ledstate;

@Override



if(savedInstanceState != null){

ledstate=savedInstanceState.getBoolean("state",false);

}

108

else{

ledstate = false;

}

setContentView(R.layout.leds);

onoff = (Button)findViewById(R.id.switch1);

if (ledstate == true)

{

onoff.setBackgroundResource(R.drawable.switch_on);

}

onoff.setOnClickListener(new View.OnClickListener() {

public void onClick(View v) {

if (ledstate == true)

{

ledstate = false;

onoff.setBackgroundResource(R.drawable.switch_off);

}

else

{

ledstate = true;

onoff.setBackgroundResource(R.drawable.switch_on);

}

Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, leds, ledstate);

}

});

}

@Override



outState.putBoolean("state", ledstate);

}

@Override


super.onStop();

// save state

Bundle bundle = new Bundle();

bundle.putBoolean("state", ledstate);


}

109

}










public class Manual extends Activity {


@Override



/* if (savedInstanceState != null){


}

else popup_flag = false;*/



GridView view = (GridView)inflater.inflate(R.layout.man, null);


new IconItem ("Servos", R.drawable.servo_norm),

new IconItem ("Motores", R.drawable.motor_norm),

new IconItem ("Presión", R.drawable.pres_norm)));





if(position == 0){

myIntent = new Intent(v.getContext(), ServoSel.class);

110

myIntent.putExtra("type", 2);

}

if(position == 1){

myIntent = new Intent(v.getContext(), Motor.class);

}

if(position == 2){

myIntent = new Intent(v.getContext(), PresSel.class);

}


}

});

}

}


import org.json.JSONObject;

import android.content.BroadcastReceiver;



import android.content.IntentFilter;





import android.widget.ProgressBar;

import android.widget.SeekBar;




public class MasterLight extends BTActivity {


private TextView left;

private TextView center;

private TextView right;

private TextView mast;

private Button save;

111

private Button setthre1;



private Button savethre1;



private ProgressBar level1;



private TextView textthreshold1;



private SeekBar t1;

private SeekBar t2;

private SeekBar t3;

int umb1 =0;

int umb2 =0;

int umb3 =0;

public boolean lightok = false;

private JSONObject jObject;

public String exString = "{\"light\": {\"l1\": \"211\", \"l2\": \"222\", \"l3\": \"233\", \"l4\": \"111\"}}";

public String exString2 = "{\"threshold\": {\"t1\": \"15\", \"t2\": \"12\", \"t3\": \"20\"}}";

private Boolean freceived =false;

private ArduinoReceiverThresholds thres = new ArduinoReceiverThresholds();

private ArduinoReceiverLevels levels = new ArduinoReceiverLevels();

@Override



setContentView(R.layout.lightandmore);

left = (TextView) findViewById(R.id.value1);

center = (TextView) findViewById(R.id.value2);

right = (TextView) findViewById(R.id.value3);

mast = (TextView) findViewById(R.id.value4);

textthreshold1 = (TextView) findViewById(R.id.umbral1);



112

save = (Button) findViewById(R.id.save);

OnClickListener save_list = new OnClickListener()

{

public void onClick(View v)

{

Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, cls, master);

}

};

save.setOnClickListener(save_list);

setthre1 = (Button)findViewById(R.id.import1);

setthre1.setOnClickListener(new View.OnClickListener() {


t1.setProgress(umb1);

}

});





}

});





}

});

savethre1 = (Button)findViewById(R.id.save1);

savethre1.setOnClickListener(new View.OnClickListener() {


Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, ctsu, thresholds[1]);

}

});


113



Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, ctsd, thresholds[2]);

}

});




Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, ctst, thresholds[3]);

}

});

level1=(ProgressBar)findViewById(R.id.progressIzq);

level2=(ProgressBar)findViewById(R.id.progressCent);

level3=(ProgressBar)findViewById(R.id.progressDer);

t1 =(SeekBar)findViewById(R.id.seekBar1);

t1.setOnSeekBarChangeListener(sb1);





}

private SeekBar.OnSeekBarChangeListener sb1

= new SeekBar.OnSeekBarChangeListener(){

@Override

public void onProgressChanged(SeekBar seekBar, int progress,

boolean fromUser) {


thresholds[1]=t1.getProgress();

textthreshold1.setText(Integer.toString(thresholds[1])+ "%");

}

@Override

public void onStartTrackingTouch(SeekBar seekBar) {

114

}

@Override

public void onStopTrackingTouch(SeekBar seekBar) {

}};



@Override


boolean fromUser) {




}

@Override


}

@Override


}};



@Override


boolean fromUser) {




}

@Override


}

115

@Override


}};

@Override

protected void onStart() {

super.onStart();

// in order to receive broadcasted intents we need to register our receiver

registerReceiver(thres, new IntentFilter(AmarinoIntent.ACTION_RECEIVED));

// this is how you tell Amarino to connect to a specific BT device from within your own code

Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, ctini, "0");

}

@Override


super.onStop();

// if you connect in onStart() you must not forget to disconnect when your app is closed


Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, clo, "0");

// do never forget to unregister a registered receiver

if (freceived==true) unregisterReceiver(levels);

else unregisterReceiver(thres);

}

/**

* ArduinoReceiver is responsible for catching broadcasted Amarino

* events.

*

* It extracts data from the intent and updates the graph accordingly.

*/

private class ArduinoReceiverLevels extends BroadcastReceiver {

116

@Override

public void onReceive(Context context, Intent intent) {

String data = null;

// the device address from which the data was sent, we don't need it here but to demonstrate how you retrieve it

final String address = intent.getStringExtra(AmarinoIntent.EXTRA_DEVICE_ADDRESS);

// the type of data which is added to the intent

final int dataType = intent.getIntExtra(AmarinoIntent.EXTRA_DATA_TYPE, -1);

// we only expect String data though, but it is better to check if really string was sent

// later Amarino will support differnt data types, so far data comes always as string and

// you have to parse the data to the type you have sent from Arduino, like it is shown below

if (dataType == AmarinoIntent.STRING_EXTRA){

data = intent.getStringExtra(AmarinoIntent.EXTRA_DATA);

if (data != null){

try {

parse(data);

} catch (Exception e) {

e.printStackTrace();

}

left.setText(Integer.toString(lights[1]));

center.setText(Integer.toString(lights[2]));

right.setText(Integer.toString(lights[3]));

mast.setText(Integer.toString(master));

level1.setProgress(lights[1]);



umb1 = (lights[1] /8);



setthre1.setText(Integer.toString(umb1) + "%");



}

}

}

}

117

private void parse(String jString) throws Exception {

jObject = new JSONObject(jString);

JSONObject menuObject = jObject.getJSONObject("light");

//String attributeId = menuObject.getString("id");

lights[1] = menuObject.getInt("l1");



master = menuObject.getInt("l4");

}

private class ArduinoReceiverThresholds extends BroadcastReceiver {

@Override


String data = null;










if (data != null){

try {

parseValue(data);



}

118

textthreshold1.setText(Integer.toString(thresholds[1]));



t1.setProgress(thresholds[1]);



changeRegister();

freceived=true;

}

}

}

}

private void parseValue(String jString) throws Exception {


JSONObject menuObject2 = jObject.getJSONObject("threshold");

thresholds[1] = menuObject2.getInt("t1");



}

private void changeRegister(){

unregisterReceiver(thres);

Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, cto, "0");

Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, clini, "0");

registerReceiver(levels, new IntentFilter(AmarinoIntent.ACTION_RECEIVED));

}

}





119


import android.view.animation.TranslateAnimation;


import android.widget.EditText;




public class Motor extends BTActivity {

Button down1;

Button up1;

ImageView base1;

Button down2;

Button up2;

ImageView base2;

Button down3;

Button up3;

ImageView base3;

View layout;


@Override



setContentView(R.layout.motor);

base1 = (ImageView)findViewById(R.id.test_image1);



down1 = (Button)findViewById(R.id.down1);

down1.setOnClickListener(new View.OnClickListener() {

@Override


//edit.setVisibility(View.VISIBLE);

TranslateAnimation slide = new TranslateAnimation(0, 0, 0,200 );

slide.setDuration(2000);

slide.setFillAfter(true);

base1.startAnimation(slide);

up1.setEnabled(true);

down1.setEnabled(false);

120

Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, mdown, 1);

}

});

up1 = (Button)findViewById(R.id.up1);

up1.setOnClickListener(new View.OnClickListener() {

@Override







up1.setEnabled(false);

down1.setEnabled(true);

Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, mup, 1);

}

});



@Override










}

});



@Override



121








}

});



@Override










}

});



@Override










}

122

});

layout = (View) findViewById(R.id.layout);

}

@Override


super.onStart();




}

}






public class PresSel extends BTActivity{

Button up;

Button down;

@Override



setContentView(R.layout.selectpres);

down = (Button)findViewById(R.id.button2);

down.setOnClickListener(new View.OnClickListener() {

@Override


123


myIntent = new Intent(v.getContext(), PressureDown.class);


}

});

up = (Button)findViewById(R.id.button1);

up.setOnClickListener(new View.OnClickListener() {

@Override



myIntent = new Intent(v.getContext(), PressureUp.class);


}

});

}

}


import org.json.JSONArray;
















public class PressureDown extends BTActivity {


124




private TextView text1;





public String exString = "{\"pres\": {\"u1\": \"211\", \"d1\": \"211\", \"u2\": \"222\",\"d2\": \"211\", \"u3\": \"233\",\"d3\": \"211\"}}";

private ArduinoReceiver arduinoReceiver = new ArduinoReceiver();

@Override



setContentView(R.layout.simplepressure);




text1 = (TextView) findViewById(R.id.text1);



}

@Override


super.onStart();


registerReceiver(arduinoReceiver, new IntentFilter(AmarinoIntent.ACTION_RECEIVED));


Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, pini, 2);

/* left.setText(Integer.toString(pressures[1][1]));

center.setText(Integer.toString(pressures[1][2]));

right.setText(Integer.toString(pressures[1][3]));*/

125

text1.setText("Inferior");



}

@Override


super.onStop();



Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, po, "0");


unregisterReceiver(arduinoReceiver);

}

/**


* events.

*


*/

private class ArduinoReceiver extends BroadcastReceiver {

@Override


String data = null;








126



if (data != null){

try {

parse(data);



}

left.setText(Integer.toString(pressures[2][1]));


right.setText(Integer.toString(pressures[2][3]));

}

}

}

}



JSONObject menuObject = jObject.getJSONObject("pres");


pressures[2][1] = menuObject.getInt("d1");



}

}


import org.json.JSONArray;




127













public class PressureUp extends BTActivity {










public String exString = "{\"pres\": {\"u1\": \"211\", \"d1\": \"211\", \"u2\": \"222\",\"d2\": \"211\", \"u3\": \"233\",\"d3\": \"211\"}}";


@Override



setContentView(R.layout.simplepressure);







}

128

@Override


super.onStart();




Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, pini, 1);

/* left.setText(Integer.toString(pressures[1][1]));


right.setText(Integer.toString(pressures[1][3]));*/

text1.setText("Superior");



}

@Override


super.onStop();



Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, po, 1);


unregisterReceiver(arduinoReceiver);

}

/**


* events.

*


*/


@Override


129

String data = null;










if (data != null){

try {

parse(data);



}

left.setText(Integer.toString(pressures[1][1]));


right.setText(Integer.toString(pressures[1][3]));

}

}

}

}



JSONObject menuObject = jObject.getJSONObject("pres");


pressures[1][1] = menuObject.getInt("u1");



130

}

}







import android.content.SharedPreferences;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.graphics.Matrix;


import android.preference.PreferenceManager;



import android.widget.ArrayAdapter;




import android.widget.Spinner;




public class ServoCont extends BTActivity {

final int DELAY = 150;

int pos; //variable temporal posición actual

int lastindex;

int nservo;

boolean loaded;

ImageView myImageView;

Spinner spinnerScale;

131

private static final String[] strScale

= {"Posición 1", "Posición 2", "Posición 3", "Posición 4", "Posición 5", "Posición 6", "Posición 7"};

private int SpinnerSelect = 0;

private ArrayAdapter<String> adapterScale;

private float curScale = 1F;

private float curRotate = 0F;

Bitmap bitmap;

int bmpWidth, bmpHeight;

TextView value;

TextView title;

Button prev;

Button next;

Button plus;

Button minus;

Button save;


@Override



if(savedInstanceState != null){

lastindex=savedInstanceState.getInt("index",0);

}

else{

lastindex = 0;

}

Bundle bundle = getIntent().getExtras();

nservo = bundle.getInt("selected");

setContentView(R.layout.servocont);

title = (TextView)findViewById(R.id.text);

myImageView = (ImageView)findViewById(R.id.imageview);

value = (TextView)findViewById(R.id.value);

title.setText("Servo" + nservo);

prev = (Button)findViewById(R.id.previous);

prev.setOnClickListener(new View.OnClickListener() {


if (SpinnerSelect == 0) SpinnerSelect = 6;

else SpinnerSelect--;

spinnerScale.setSelection(SpinnerSelect);

132

}

});

next = (Button)findViewById(R.id.next);

next.setOnClickListener(new View.OnClickListener() {



else SpinnerSelect++;


}

});

spinnerScale = (Spinner)findViewById(R.id.scale);

adapterScale = new ArrayAdapter<String>(this,

R.layout.my_spinner, strScale);

adapterScale.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

spinnerScale.setAdapter(adapterScale);


curScale = 1F;

//bitmap = BitmapFactory.decodeFile(imageInSD);

bitmap = BitmapFactory.decodeResource(getResources(),

R.drawable.rotate);

bmpWidth = bitmap.getWidth();

bmpHeight = bitmap.getHeight();

drawMatrix();

spinnerScale.setOnItemSelectedListener(spinnerScaleOnItemSelectedListener);

}

@Override


super.onStart();

}

133

@Override



outState.putInt("index", lastindex);

}

@Override


super.onStop();

}

private void drawMatrix(){

Matrix matrix = new Matrix();

matrix.postScale(curScale, curScale);

matrix.postRotate(curRotate);

Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bmpWidth, bmpHeight, matrix, true);

myImageView.setImageBitmap(resizedBitmap);

}

private Spinner.OnItemSelectedListener spinnerScaleOnItemSelectedListener

= new Spinner.OnItemSelectedListener(){

@Override

public void onItemSelected(AdapterView<?> arg0, View arg1,

int index, long arg3) {

SpinnerSelect= index;

refresh(index);

}

@Override

public void onNothingSelected(AdapterView<?> arg0) {



//curScale = floatScale[SpinnerSelect];

}};

134

private void refresh (int index){

if (index >=lastindex) curRotate = curRotate + 100;

else curRotate = curRotate - 100;

drawMatrix();

if (nservo==1){

Amarino.sendDataToArduino(this, DEVICE_ADDRESS, sspu, index);

}

else if (nservo==2)

{

Amarino.sendDataToArduino(this, DEVICE_ADDRESS, sspd, index);

}

else if (nservo==3)

{

Amarino.sendDataToArduino(this, DEVICE_ADDRESS, sspt, index);

}

lastindex=index;

}

}










public class ServoSel extends Activity {


int type;

@Override



135


type = bundle.getInt("type");


GridView view = (GridView)inflater.inflate(R.layout.servo_sel, null);


new IconItem ("Servo Izquierda", R.drawable.servo_norm),

new IconItem ("Servo Centro", R.drawable.servo_norm),

new IconItem ("Servo Derecha", R.drawable.servo_norm)));






if (type==1) myIntent = new Intent(v.getContext(), ServoSF.class);

else if (type ==2) myIntent = new Intent(v.getContext(), ServoCont.class);

myIntent.putExtra("selected", position + 1);


}

});

}

}








import android.content.SharedPreferences;

import android.graphics.Bitmap;

136

import android.graphics.BitmapFactory;

import android.graphics.Matrix;


import android.preference.PreferenceManager;

import android.util.Log;



import android.widget.ArrayAdapter;




import android.widget.Spinner;




public class ServoSF extends BTActivity {

final int DELAY = 150;

SeekBar servoOne;


int pos; //variable temporal posición actual

long lastChange;

public String exString = "{\"servo1\": {\"p1\": \"10\", \"p2\": \"20\", \"p3\": \"30\", \"p4\": \"40\", \"p5\": \"50\", \"p6\": \"60\", \"p7\": \"70\"}}";

int nservo;


boolean loaded;

private final String imageInSD = "/sdcard/er.PNG";

ImageView myImageView;

Spinner spinnerScale;

SeekBar seekbarRotate;

private static final String[] strScale

= {"Posición 1", "Posición 2", "Posición 3", "Posición 4", "Posición 5", "Posición 6", "Posición 7"};

private static final Float[] floatScale

= {0.2F, 0.5F, 1F, 2F, 5F};

private int SpinnerSelect = 0;

private ArrayAdapter<String> adapterScale;

137

private float curScale = 1F;

private float curRotate = 0F;

Bitmap bitmap;

int bmpWidth, bmpHeight;

TextView value;

TextView title;

Button prev;

Button next;

Button plus;

Button minus;

Button save;


@Override




nservo = bundle.getInt("selected");

setContentView(R.layout.servo);

title = (TextView)findViewById(R.id.text);

myImageView = (ImageView)findViewById(R.id.imageview);

value = (TextView)findViewById(R.id.value);

title.setText("Servo" + nservo);

prev = (Button)findViewById(R.id.previous);

prev.setOnClickListener(new View.OnClickListener() {



else SpinnerSelect--;


}

});

next = (Button)findViewById(R.id.next);

next.setOnClickListener(new View.OnClickListener() {



else SpinnerSelect++;


}

});

plus = (Button)findViewById(R.id.plus);

138

plus.setOnClickListener(new View.OnClickListener() {


pos= seekbarRotate.getProgress() + 2;

seekbarRotate.setProgress(pos);

}

});

minus = (Button)findViewById(R.id.minus);

minus.setOnClickListener(new View.OnClickListener() {


pos= seekbarRotate.getProgress() - 2;


}

});

save = (Button)findViewById(R.id.save);

save.setOnClickListener(new View.OnClickListener() {


Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, sfsp, SpinnerSelect);

try{

Thread.sleep(100);

}

catch (Exception e){}

Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, sfs, pos);

servopos[nservo][SpinnerSelect]=pos;

}

});

spinnerScale = (Spinner)findViewById(R.id.scale);

seekbarRotate = (SeekBar)findViewById(R.id.rotate);

adapterScale = new ArrayAdapter<String>(this,

R.layout.my_spinner, strScale);

adapterScale.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

spinnerScale.setAdapter(adapterScale);


curScale = 1F;

139

//bitmap = BitmapFactory.decodeFile(imageInSD);

bitmap = BitmapFactory.decodeResource(getResources(),

R.drawable.rotate);

bmpWidth = bitmap.getWidth();

bmpHeight = bitmap.getHeight();

drawMatrix();

spinnerScale.setOnItemSelectedListener(spinnerScaleOnItemSelectedListener);

seekbarRotate.setOnSeekBarChangeListener(seekbarRotateSeekBarChangeListener);

}

@Override


super.onStart();




Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, sfss, nservo);

// load last state

SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

pos = prefs.getInt("pos", 0);

// set seekbars and feedback color according to last state


new Thread(){

public void run(){

try {

Thread.sleep(6000);

} catch (InterruptedException e) {}

updatePos();

}

}.start();

}

140

@Override


super.onStop();

// save state

pos= seekbarRotate.getProgress();

PreferenceManager.getDefaultSharedPreferences(this)

.edit()

.putInt("pos", pos)

.putBoolean("flag", loaded)

.commit();


}

private void updatePos(){

// I have chosen random small letters for the flag 'o' for red, 'p' for green and 'q' for blue

// you could select any small letter you want

// however be sure to match the character you register a function for your in Arduino sketch

Amarino.sendDataToArduino(this, DEVICE_ADDRESS, sfsd, pos);

//textView2.setText(pos);

}

private void drawMatrix(){

Matrix matrix = new Matrix();

matrix.postScale(curScale, curScale);

matrix.postRotate(curRotate);

Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bmpWidth, bmpHeight, matrix, true);

myImageView.setImageBitmap(resizedBitmap);

}

private SeekBar.OnSeekBarChangeListener seekbarRotateSeekBarChangeListener


@Override


boolean fromUser) {

141


curRotate = (float)progress;

drawMatrix();

value.setText(Integer.toString(progress/2));

if (System.currentTimeMillis() - lastChange > DELAY ){

updateState(seekBar);

lastChange = System.currentTimeMillis();

}

}

@Override




}

@Override




}};

private void updateState(final SeekBar seekBar) {

pos = (seekBar.getProgress())/2;

updatePos();

}

private Spinner.OnItemSelectedListener spinnerScaleOnItemSelectedListener

= new Spinner.OnItemSelectedListener(){

@Override

public void onItemSelected(AdapterView<?> arg0, View arg1,

int index, long arg3) {


//curScale = floatScale[arg2];

//drawMatrix();

SpinnerSelect= index;

refresh();

}

142

@Override

public void onNothingSelected(AdapterView<?> arg0) {



//curScale = floatScale[SpinnerSelect];

}};


@Override


String data = null;










if ((data != null)&(loaded ==false)){

try {

parse(data);



}

refresh();

int x=0;

for (int i = 0; i < 7; i++) {

if (servopos[nservo][i] != 0) x++;

}

if (x == 7) {

Amarino.sendDataToArduino(getBaseContext(), DEVICE_ADDRESS, sfo, "0");

143

loaded = true;

}

}

}

}

}



JSONObject menuObject = jObject.getJSONObject("servo" + nservo);


for (int i = 0; i < 7; i++) {

servopos[nservo][i] = menuObject.getInt("p"+ (i+1));

}

}

private void refresh (){

pos = servopos[nservo][SpinnerSelect];

pos = 2*pos;


//value.setText(Integer.toString(pos));

}

}

<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="befaust.jorges119.eclipseBT" android:versionCode="1" android:versionName="1.0" > <uses-sdk android:minSdkVersion="7" /> <uses-permission android:name="android.permission.BLUETOOTH"/> <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"/> <application android:icon="@drawable/servo_norm" android:label="@string/app_name" > <activity android:label="@string/app_name" android:name=".HomeActivity" > <intent-filter > <action android:name="android.intent.action.MAIN" />

144

<category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> <activity android:label="Configuration" android:name=".Configuration" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.Configuration" /> </intent-filter> </activity> <activity android:label="Manual" android:name=".Manual" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.Manual" /> </intent-filter> </activity> <activity android:label="ServoSel" android:name=".ServoSel" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.ServoSel" /> </intent-filter> </activity> <activity android:label="ServoSF" android:name=".ServoSF" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.ServoSF" /> </intent-filter> </activity> <activity android:label="Motor" android:name=".Motor" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.Motor" /> </intent-filter> </activity> <activity android:label="MasterLight" android:name=".MasterLight" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.MasterLight" /> </intent-filter> </activity> <activity android:label="Leds" android:name=".Leds" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.Leds" /> </intent-filter> </activity>

145

<activity android:label="PressureUp" android:name=".PressureUp" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.PressureUp" /> </intent-filter> </activity> <activity android:label="PressureDown" android:name=".PressureDown" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.PressureDown" /> </intent-filter> </activity> <activity android:label="PresSel" android:name=".PresSel" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.PresSel" /> </intent-filter> </activity> <activity android:label="ServoCont" android:name=".ServoCont" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.ServoCont" /> </intent-filter> </activity> <activity android:label="Sys" android:name=".Sys" > <intent-filter > <action android:name="befaust.jorges119.eclipseBT.Sys" /> </intent-filter> </activity> </application> </manifest>

Apéndice F: Variantes & PnP

Low PnP Designator Footprint Mid X Mid Y Ref X Ref Y Pad X Pad Y TB Rotation Comment

P3 HDR2X3 4710mil 3265mil 4610mil 3215mil 4610mil 3215mil T 0.00 Header 3X2H, PIN CORTO

C1 T491X 2290mil 6375mil 2290mil 6375mil 2183.7mil 6375mil T 180.00 Cap Pol3, 407-0025

C2 CapElec 3237.5mil 6330mil 3240mil 6330mil 3340mil 6330mil T 0.00 Cap Pol3, 737-3021

C3 C0805 2315mil 6210mil 2315mil 6210mil 2285.472mil 6210mil T 360.00 0.1u, 264-4422

146

C4 C0805 3615mil 3949.999mil 3615mil 3949.999mil 3615mil 3979.527mil B 270.00 Cap Semi, 264-4258

C6 C0805 3705mil 3955mil 3705mil 3955mil 3705mil 3925.472mil T 90.00 Cap Semi, 264-4258


C10 C0805 3075mil 4735mil 3075mil 4735mil 3104.528mil 4735mil T 180.00 Cap Semi, 264-4422




D1 DIODE_SMC 3250mil 6025mil 3250mil 6025mil 3100mil 6025mil T 180.00 Diode 1N4005, 629-0473

D2 3.2X1.6X1.1 2540mil 5560mil 2540mil 5560mil 2540mil 5628.898mil T 270.00 HSMD-C150, 692-0969

P1 HDR2X3 2770mil 4650mil 2720mil 4750mil 2720mil 4750mil T 270.00 Header 3X2, PIN CORTO

P2 HDR1X2 4435mil 3880mil 4435mil 3930mil 4435mil 3930mil T 270.00 Header 2

S1 HDR1X3 2140mil 3540mil 2140mil 3440mil 2140mil 3440mil T 90.00 Header 3H, PIN CORTO 90º


LEFT HDR2X6 3890mil 6190mil 3640mil 6140mil 3640mil 6140mil T 360.00 Header 6X2H, PIN CORTO

RIGTH HDR2X6 5560mil 6190mil 5310mil 6140mil 5310mil 6140mil T 360.00 Header 6X2H, PIN CORTO





CENTER HDR2X6 4725mil 6190mil 4475mil 6140mil 4475mil 6140mil T 360.00 Header 6X2H, PIN CORTO

SPARE HDR2X6 6395mil 6190mil 6145mil 6140mil 6145mil 6140mil T 360.00 Header 6X2H, PIN CORTO

MASTER HDR2X6 7230mil 6190mil 6980mil 6140mil 6980mil 6140mil T 360.00 Header 6X2H, PIN CORTO

OUT1 HDR1X20 3355mil 3215mil 4305mil 3215mil 4305mil 3215mil T 180.00 Header 20, PIN HEMBRA


R1 6-0805_N 6470mil 5790mil 6470mil 5789.999mil 6470mil 5754.567mil B 90.00 Res3, 679-1207

R2 6-0805_N 2540mil 5830.001mil 2540mil 5830mil 2540mil 5794.568mil T 90.00 1K, 740-9063

R4 SO-16 5170.001mil 4865mil 5170mil 4865mil 5033.19mil 5040mil T 270.00 EXBM16P, 522-4992

R5 6-0805_N 3630.001mil 4935mil 3630mil 4935mil 3594.568mil 4935mil T 360.00 Res3, 740-9063










R15 6-0805_N 5100mil 3700mil 5100mil 3700mil 5100mil 3735.434mil T 270.00 Res3, 740-9063




R19 6-0805_N 3510mil 3425mil 3510mil 3425mil 3545.434mil 3425mil T 180.00 Res3, 679-1187


U2 MP04A_N 2810mil 5715mil 2810mil 5715mil 2900.552mil 5829.174mil T 270.00 LM2940IMP-5.0/NOPB, 727-4790

U3 SO20_N 5865mil 5545mil 5865mil 5545mil 6044.134mil 5320mil T 180.00 L293DD, 714-0625

U4 100A_N 3505mil 4440mil 3505mil 4440mil 3207.756mil 4676.22mil T 360.00 ATmega2560-16AU, 666-4530


Y1 HC49/4H_SMX 3510mil 3745mil 3510mil 3745mil 3697.008mil 3745mil T 180.00 16MHz, 478-9505

J1 DC_JACK 2686.575mil 6177.815mil 2785mil 6595mil 2785mil 6055.63mil T 270.00 PWR2.5, 487-848

High PnP

147

Designator Footprint Mid X Mid Y Ref X Ref Y Pad X Pad Y TB Rotation Comment

P3 HDR2X3 119.634mm 82.931mm 117.094mm 81.661mm 117.094mm 81.661mm T 0.00 Header 3X2H, PIN CORTO

BT1 WT11 174.146mm 90.436mm 183.896mm 97.536mm 183.896mm 97.536mm T 270.00 Bluegiga WT11, 537-846

C1 T491X 58.166mm 161.925mm 58.166mm 161.925mm 55.466mm 161.925mm T 180.00 Cap Pol3, 407-0025

C2 CapElec 82.2325mm 160.782mm 82.296mm 160.782mm 84.836mm 160.782mm T 0.00 Cap Pol3, 737-3021

C3 C0805 58.801mm 157.734mm 58.801mm 157.734mm 58.051mm 157.734mm T 360.00 0.1u, 264-4422

C4 C0805 91.821mm 100.33mm 91.821mm 100.33mm 91.821mm 101.08mm B 270.00 Cap Semi, 264-4258

C5 C0805 113.03mm 124.714mm 113.03mm 124.714mm 113.03mm 123.964mm T 90.00 Cap Semi, 264-4422












C19 293D 126.111mm 144.653mm 126.111mm 144.653mm 126.111mm 147.653mm B 90.00 Cap Pol3, 684-3998





D1 DIODE_SMC 82.55mm 153.035mm 82.55mm 153.035mm 78.74mm 153.035mm T 180.00 Diode 1N4005, 629-0473

D2 3.2X1.6X1.1 64.516mm 141.224mm 64.516mm 141.224mm 64.516mm 142.974mm T 270.00 HSMD-C150, 692-0969

J2 1-1470156 57.994mm 147.955mm 45.339mm 147.955mm 60.349mm 146.705mm T 180.00 1-1470156-1, 748-0866

P1 HDR2X3 70.358mm 118.11mm 69.088mm 120.65mm 69.088mm 120.65mm T 270.00 Header 3X2, PIN CORTO

P2 HDR1X2 112.649mm 98.552mm 112.649mm 99.822mm 112.649mm 99.822mm T 270.00 Header 2

P4 HDR2X3 166.243mm 110.617mm 167.513mm 108.077mm 167.513mm 108.077mm T 90.00 Header 3X2, PIN CORTO

S1 HDR1X3 54.356mm 89.916mm 54.356mm 87.376mm 54.356mm 87.376mm T 90.00 Header 3H, PIN CORTO 90º


LEFT HDR2X6 98.806mm 157.226mm 92.456mm 155.956mm 92.456mm 155.956mm T 360.00 Header 6X2H, PIN CORTO

RIGTH HDR2X6 141.224mm 157.226mm 134.874mm 155.956mm 134.874mm 155.956mm T 360.00 Header 6X2H, PIN CORTO





CENTER HDR2X6 120.015mm 157.226mm 113.665mm 155.956mm 113.665mm 155.956mm T 360.00 Header 6X2H, PIN CORTO

SPARE HDR2X6 162.433mm 157.226mm 156.083mm 155.956mm 156.083mm 155.956mm T 360.00 Header 6X2H, PIN CORTO

MASTER HDR2X6 183.642mm 157.226mm 177.292mm 155.956mm 177.292mm 155.956mm T 360.00 Header 6X2H, PIN CORTO

OUT1 HDR1X20 85.217mm 81.661mm 109.347mm 81.661mm 109.347mm 81.661mm T 180.00 Header 20, PIN HEMBRA

OUT2 HDR1X20 196.85mm 132.588mm 196.85mm 156.718mm 196.85mm 156.718mm T 270.00 Header 20, PIN HEMBRA

Q5 SOT-23_N 122.047mm 131.318mm 122.047mm 131.318mm 120.922mm 130.368mm B 360.00 IRLML5103, 671-0435

R1 6-0805_N 164.338mm 147.066mm 164.338mm 147.066mm 164.338mm 146.166mm B 90.00 Res3, 679-1207

R2 6-0805_N 64.516mm 148.082mm 64.516mm 148.082mm 64.516mm 147.182mm T 90.00 1K, 740-9063

R3 POT4MM-2 165.735mm 123.571mm 165.735mm 123.571mm 164.585mm 125.571mm T 270.00 10K, 725-0101

R4 SO-16 131.318mm 123.571mm 131.318mm 123.571mm 127.843mm 128.016mm T 270.00 EXBM16P, 522-4992

R5 6-0805_N 92.202mm 125.349mm 92.202mm 125.349mm 91.302mm 125.349mm T 360.00 Res3, 740-9063





148





















RT1 6-0805_N 111.252mm 132.334mm 111.252mm 132.334mm 110.352mm 132.334mm T 0.00 Res Thermal, 691-7500

U1 M08A_N 166.751mm 140.843mm 166.751mm 140.843mm 169.151mm 142.748mm B 180.00 LM335M/NOPB, 535-9111

U2 MP04A_N 71.374mm 145.161mm 71.374mm 145.161mm 73.674mm 148.061mm T 270.00 LM2940IMP-5.0/NOPB, 727-4790

U3 SO20_N 148.971mm 140.843mm 148.971mm 140.843mm 153.521mm 135.128mm T 180.00 L293DD, 714-0625

U4 100A_N 89.027mm 112.776mm 89.027mm 112.776mm 81.477mm 118.776mm T 360.00 ATmega2560-16AU, 666-4530

U5 SO20_N 179.578mm 140.716mm 179.578mm 140.716mm 175.028mm 146.431mm T 0.00 L293DD, 714-0625

U7 SOP8_N 69.469mm 107.061mm 69.469mm 107.061mm 66.969mm 105.156mm B 360.00 ST95P08M1, 686-2258

U8 32A_N 140.208mm 103.505mm 140.208mm 103.505mm 137.408mm 99.305mm T 90.00 ATmega328-AU, 738-0432

U9 MF05A_N 117.602mm 147.955mm 117.602mm 147.955mm 118.552mm 146.755mm B 90.00 LP2985AIM5-3.3, 652-0033

U11 D008_L 137.16mm 143.764mm 137.16mm 143.764mm 139.51mm 145.669mm B 180.00 LM358D, 661-0549

Y1 HC49/4H_SMX 89.154mm 95.123mm 89.154mm 95.123mm 93.904mm 95.123mm T 180.00 16MHz, 478-9505

Y2 HC49/4H_SMX 139.954mm 89.662mm 139.954mm 89.662mm 135.204mm 89.662mm T 360.00 16MHz, 478-9505

J1 DC_JACK 68.239mm 156.9165mm 70.739mm 167.513mm 70.739mm 153.813mm T 270.00 PWR2.5, 487-848

Prototype PnP Designator Footprint Mid X Mid Y Ref X Ref Y Pad X Pad Y TB Rotation Comment

P3 HDR2X3 4710mil 3265mil 4610mil 3215mil 4610mil 3215mil T 0.00 Header 3X2H, PIN CORTO

BT1 WT11 6856.142mil 3560.472mil 7240mil 3840mil 7240mil 3840mil T 270.00 Bluegiga WT11, 537-846

C1 T491X 2290mil 6375mil 2290mil 6375mil 2183.7mil 6375mil T 180.00 Cap Pol3, 407-0025

C2 CapElec 3237.5mil 6330mil 3240mil 6330mil 3340mil 6330mil T 0.00 Cap Pol3, 737-3021

C3 C0805 2315mil 6210mil 2315mil 6210mil 2285.472mil 6210mil T 360.00 0.1u, 264-4422












149


C16 C0805 5439.999mil 4345mil 5439.999mil 4345mil 5410.471mil 4345mil B 360.00 Cap Semi, 264-4422









D1 DIODE_SMC 3250mil 6025mil 3250mil 6025mil 3100mil 6025mil T 180.00 Diode 1N4005, 629-0473

D2 3.2X1.6X1.1 2540mil 5560mil 2540mil 5560mil 2540mil 5628.898mil T 270.00 HSMD-C150, 692-0969

D3 3.2X1.6X1.1 3243.898mil 5165mil 3243.898mil 5165mil 3175mil 5165mil T 360.00 HSMD-C150, 692-0969

D4 3.2X1.6X1.1 3248.898mil 5290mil 3248.898mil 5290mil 3180mil 5290mil T 360.00 HSMD-C150, 692-0969

J2 1-1470156 2283.228mil 5825mil 1785mil 5825mil 2375.944mil 5775.788mil T 180.00 1-1470156-1, 748-0866


P2 HDR1X2 4435mil 3880mil 4435mil 3930mil 4435mil 3930mil T 270.00 Header 2


P5 HDR1X14 6940mil 4060mil 7590mil 4060mil 7590mil 4060mil T 180.00 MHDR1X14

P6 HDR1X14 6940mil 3110mil 7590mil 3110mil 7590mil 3110mil T 180.00 MHDR1X14



LEFT HDR2X6 3890mil 6190mil 3640mil 6140mil 3640mil 6140mil T 360.00 Header 6X2H, PIN CORTO

RIGTH HDR2X6 5560mil 6190mil 5310mil 6140mil 5310mil 6140mil T 360.00 Header 6X2H, PIN CORTO





CENTER HDR2X6 4725mil 6190mil 4475mil 6140mil 4475mil 6140mil T 360.00 Header 6X2H, PIN CORTO

SPARE HDR2X6 6395mil 6190mil 6145mil 6140mil 6145mil 6140mil T 360.00 Header 6X2H, PIN CORTO

MASTER HDR2X6 7230mil 6190mil 6980mil 6140mil 6980mil 6140mil T 360.00 Header 6X2H, PIN CORTO



Q1 SOT23_N 5800mil 5714.999mil 5800mil 5714.999mil 5762.598mil 5756.337mil B 270.00 PDTC114YT, 518-2775




Q5 SOT-23_N 4804.999mil 5170mil 4804.999mil 5170mil 4760.707mil 5132.598mil B 360.00 IRLML5103, 671-0435


R2 6-0805_N 2540mil 5830.001mil 2540mil 5830mil 2540mil 5794.568mil T 90.00 1K, 740-9063

R3 POT4MM-2 6525mil 4865mil 6525mil 4865mil 6479.724mil 4943.74mil T 270.00 10K, 725-0101

R4 SO-16 5170.001mil 4865mil 5170mil 4865mil 5033.19mil 5040mil T 270.00 EXBM16P, 522-4992













150










R26 6-0805_N 5514.999mil 3390mil 5514.999mil 3390mil 5550.433mil 3390mil B 180.00 Res3, 679-1187



R29 6-0805_N 2968.898mil 5165mil 2968.898mil 5165mil 3004.332mil 5165mil T 180.00 Res3, 740-9063

R30 6-0805_N 2963.898mil 5280mil 2963.898mil 5280mil 2999.332mil 5280mil T 180.00 Res3, 740-9063

R31 6-0805_N 5520mil 5159.999mil 5520mil 5159.999mil 5520mil 5195.433mil B 270.00 Res3, 740-9072


RT1 6-0805_N 4380.001mil 5210mil 4380mil 5210mil 4344.568mil 5210mil T 0.00 Res Thermal, 691-7500

U1 M08A_N 6564.999mil 5545mil 6564.999mil 5545mil 6659.487mil 5620mil B 180.00 LM335M/NOPB, 535-9111

U2 MP04A_N 2810mil 5715mil 2810mil 5715mil 2900.552mil 5829.174mil T 270.00 LM2940IMP-5.0/NOPB, 727-4790


U4 100A_N 3505mil 4440mil 3505mil 4440mil 3207.756mil 4676.22mil T 360.00 ATmega2560-16AU, 666-4530


U6 SOT-23-CH6_N 4259.999mil 5575mil 4259.999mil 5575mil 4212.755mil 5537.598mil B 360.00 MCP3421A0T-E/CH, 669-6076

U7 SOP8_N 2734.999mil 4215mil 2734.999mil 4215mil 2636.573mil 4140mil B 360.00 ST95P08M1, 686-2258

U8 32A_N 5520mil 4075mil 5520mil 4075mil 5409.764mil 3909.646mil T 90.00 ATmega328-AU, 738-0432

U10 SSOP-28_N 3654.999mil 5470mil 3654.999mil 5470mil 3519.173mil 5303.662mil B 360.00 FT232RL-Reel, 406-580

U11 D008_L 5399.999mil 5660mil 5399.999mil 5660mil 5492.519mil 5735mil B 180.00 LM358D, 661-0549

W1 RAD-0.2 7080mil 4965mil 7080mil 4965mil 6980mil 4965mil T 360.00 Jumper





J1 DC_JACK 2686.575mil 6177.815mil 2785mil 6595mil 2785mil 6055.63mil T 270.00 PWR2.5, 487-848

Apéndice G: BOM

Comment Description Designator Quantity Value Ref RS

Bluegiga WT11 Bluegiga WT11-A BT1 1,00 537-846

Cap Pol3 Polarized Capacitor (Surface Mount) C1 1,00 22uF 407-0025

Cap Pol3 Polarized Capacitor (Surface Mount) C2 1,00 0.47uF 737-3021

Cap Semi Capacitor (Semiconductor SIM Model) C4, C6, C7, C14, C17, C18 6,00 22pF 264-4258

Cap Semi Capacitor (Semiconductor SIM Model) C3,C5, C8, C10, C11, C12, C13, C15, C16, C20, C21, C22, C23, C24, C25 15,00 100n 264-4422

Cap Semi Capacitor (Semiconductor SIM Model) C9 1,00 10uF 691-1161

Cap Pol3 Polarized Capacitor (Surface Mount) C19 1,00 2.2uF 684-3998

Cap Semi Capacitor (Semiconductor SIM Model) C26 1,00 1uF 264-4450

Diode 1N4005 1 Amp General Purpose Rectifier D1 1,00 629-0473

HSMD-C150 Surface Mount Chip LED, Orange D2, D3, D4 3,00 692-0969

PWR2.5 Low Voltage Power Supply Connector J1 1,00 487-848

1-1470156-1 USB 1.1, Right Angle, Thru-Hole, B Type, Receptacle, 4 Position, White J2 1,00 748-0866

Header 3X2 Header, 3-Pin, Dual row P1, P4 2,00 PIN CORTO

Header 2 Header, 2-Pin P2 1,00

Header 3X2H Header, 3-Pin, Dual row, Right Angle P3 1,00 PIN CORTO

MHDR1X14 Header, 14-Pin P5, P6 2,00 PIN HEMBRA

Header 3H Header, 3-Pin, Right Angle P7, P8, P11, P12, P13, P14 6,00 PIN CORTO 90º

Header 6X2H Header, 6-Pin, Dual row, Right Angle P9, P10, P15, P16, P17 5,00 PIN CORTO

Header 20 Header, 20-Pin P18, P19 2,00 PIN HEMBRA

PDTC114YT NPN Resistor-equipped Transistor Q1, Q2, Q3, Q4 4,00 518-2775

IRLML5103 HEXFET Power MOSFET Q5 1,00 671-0435

10K Square Trimming Potentiometer R3 1,00 10k 725-0101

EXBM16P Common terminal Resistor Network R4 1,00 522-4992

Res3 Resistor R2,R5, R6, R8, R15, R16, R28, R29, R30 8,00 1K 740-9063

Res3 Resistor R7, R11, R14, R17, R18, R21, R31, R32 8,00 10K 740-9072

Res3 Resistor R9 1,00 150K 721-7924

Res3 Resistor R10, R22, R23 3,00 50K 740-9035

Res3 Resistor R12, R13 2,00 4.7K 740-9031

Res3 Resistor R19, R26 2,00 27 679-1187

Res3 Resistor R20, R27 2,00 1M 679-1049

Res3 Resistor R1, R24, R25 3,00 2K2 679-1207

Res Thermal Thermistor RT1 1,00 691-7500

KSS222GLFG Switch, Subminiature Side-Actuated Tact, SMT, KSS Series, Std Actuator, 2 Gull Wing Leads, SPST, 2N Force, Gold ContactS1, S2 2,00

LM335M/ NOPB Precision Temperature Sensor, 8-pin Narrow SOIC, Pb-Free U1 1,00 535-9111

LM2940IMP-5.0/ NOPB1A Low Dropout Regulator, 4-pin SOT-223, Pb-Free U2 1,00 727-4790

L293DD Push-Pull Four Channel Driver With Diode U3, U5 2,00 714-0625

ATmega2560-16AU 8-bit AVR Microcontroller, 4.5-5.5V, 256KB Flash, 4KB EEPROM, 8KB SRAM, 86 GPIO pins, 100-pin TQFP, Industrial Grade (-40°C to 85°C), Pb-FreeU4 1,00 666-4530

MCP3421A0T-E/ CH 18-Bit Analog-to-Digital Converter with I2C Interface and On-Board Reference, 6-Pin SOT-23, Extended Temperature, Tape and ReelU6 1,00 669-6076

ST95P08M1 8 Kbit Serial SPI EEPROM with Positive Clock Strobe U7 1,00 686-2258

ATmega328-AU 8-bit AVR Microcontroller, 32KB Flash, 1KB EEPROM, 2KB SRAM, 32-pin TQFP, Industrial Grade (-40°C to 85°C)U8 1,00 738-0432

LP2985AIM5-3.3 Micropower 150 mA Low-Noise Ultra Low-Dropout Regulator, 5-pin SOT-23 U9 1,00 652-0033

FT232RL-Reel USB UART Asynchronous Serial Data Transfer Chip, SSOP-28, Tape and Reel U10 1,00 406-580

LM358D Dual Operational Amplifier U11 1,00 661-0549

Jumper Jumper Wire W1, W2, W3 3,00

16MHz Surface Mount Quartz Crystal Y1, Y2 2,00 478-9505

152

Apéndice H: Planos Mecánicos

Plano 1: Ensamblaje completo

Plano 2: Revolver

Plano 3: Anclaje esclavo

Plano 4: Anclaje maestro

Unidad de Control para Fresadora CNC con Cambio Automático de...

Documents

Transcript of Unidad de Control para Fresadora CNC con Cambio Automático de...