Diseño, construcción y puesta a punto de un Teslámetro ...
71
Escola Tècnica Superior d’Enginyeria Informàtica Universitat Politècnica de València Diseño, construcción y puesta a punto de un Teslámetro mediante el sistema Arduino Trabajo Fin de Grado Grado en Ingeniería Informática Autor: Jose Galbis Soler Tutor: Jorge Más Estellés 2016/2017
Transcript of Diseño, construcción y puesta a punto de un Teslámetro ...
Escola Tècnica Superior d’Enginyeria Informàtica
Universitat Politècnica de València
Diseño, construcción y puesta a punto de unTeslámetro mediante el sistema Arduino
Trabajo Fin de Grado
Grado en Ingeniería Informática
Autor: Jose Galbis Soler
Tutor: Jorge Más Estellés
2016/2017
ResumenEste proyecto pretende obtener un Teslametro de bajo coste, elaborado a partir de hardware ysoftware libre, escogiendo como plataforma abierta Arduino junto con otros dispositivos y intentadoreutilizar objetos desechados en casa. Todo ello para poder disponer de un dispositivo para ellaboratorio de física Nikkola Tesla de la ETSINF; elaborado desde la misma universidad para eldesarrollo de la universidad.
Desarrollaremos el análisis, diseño, implementación y testeo del dispositivo resultante, poniendo enpractica distintas técnicas adquiridas durante el grado de ingeniería informática. Además de utilizardistintos buses de comunicación y corregiremos el efecto rebote de las señales eléctricas. Endefinitiva la resolución completa de proyecto de ingeniería.
Palabras clave: Arduino, Hardware libre, Teslametro, Instrumentación de laboratorio, Educativo.
ResumAquest proyecte preten obtindre un Teslametre de baix cost, elaborat a partir de hardware y softwarelliure, escollint com a plataforma oberta Arduino junt amb altres dispositius i intentant reutilitzarobjectes en des ús de casa. Tot açó per poder disposar d'un dispositiu per al laboratori de fisiacaNikkola Tesla de la ESTINF elaborat desde la mateixa universitat y per al desenvolupament de launiversitat.
Desenvoluparem el analisí, disseny, implementacio e testeg del dispositiu resultant, posant enpractica distintes tecniques adquirides al grau de ingenieria informatica. Ademes de utilitzar diversosbusos de comunicació y corregirem el efecte rebot produït a les señals electriques. En definitiva laresolucio completa d'un proyecte de ingenieria.
Paraules Clau: Arduino, Hardware lliure, Teslametre, Instrumentació de laboratori, Educatiu.
AbstractThe objective of this project is to obtain a low cost Teslameter, made with free hardware and freesoftware. Arduino has been chosen as an open platform along with other devices, and we have triedthe recycling of discarded items at home. All this in order to have a device for the Nikkola TeslaPhysics laboratory at ETSINF: created from university for the development of the University.
We have developed the analysis, design, implementation and testing of the resulting device, puttinginto practice different techniques learned during the degree on computer engineering. Moreover wehave used different buses of communication and we have corrected the rebound effect of electricalsignals. In conclusion, this work involves a complete resolution on an engineering project.
Keywords : Arduino, Open hardware, Teslameter, Laboratory instrumentation, educational.
ÍndiceCapítulo 1: Introducción..........................................................................................1-3
1.1: Motivación..............................................................................................11.2: Objetivos.................................................................................................11.3: Estructura de la memoria........................................................................21.4: Uso bibliográfico.................................................................................2-3
Capítulo 2: Análisis................................................................................................3-142.1: Introducción a los Teslámetros............................................................3-52.2: Requerimientos del dispositivo...............................................................52.3: Selección de los dispositivos...............................................................6-9
2.3.1: Comparativa Arduinos............................................................................72.3.2: Comparativa sensores Hall..................................................................7-82.3.3: Comparativa SD/microSD...................................................................8-9
2.4: Introducción a Arduino Due y los módulos seleccionados................9-142.4.1: Arduino Due......................................................................................9-102.4.2: Display LCD....................................................................................11-122.4.3: Reloj RTC Adalloger.......................................................................12-132.4.4: Lector tarjetas microSD Adalloger.......................................................132.4.5: Sensor Hall A1318...........................................................................13-142.4.6: Botonera interfaz de usuario.................................................................14
Capítulo 3: Diseño................................................................................................15-243.1: Diagramas de flujo...........................................................................15-21
3.1.1: Diagramas de flujo principal.................................................................153.1.2: Diagramas de flujo tratamiento de las muestras...................................163.1.3: Diagramas de flujo impresión de las muestras por el display...............173.1.4: Diagramas de flujo guardado de las muestras en la microSD...............183.1.5: Diagramas de flujo de la lectura de una muestras.................................193.1.6: Diagramas de flujo de la adecuación del valor captado.............................19-203.1.7: Diagramas de flujo de representación de la magnitud medida.............21
3.2: Conexionado de los componentes.....................................................22-243.3: Revestimiento y alimentación del dispositivo........................................24
Capítulo 4: Implementación.................................................................................25-374.1: Estructura de la lectura de muestras.......................................................254.2: Librerías utilizadas............................................................................26-27
4.2.1: LiquidCrystal..........................................................................................264.2.2: SPI y SD.................................................................................................264.2.3: Wire y RTClib........................................................................................27
4.3: Funciones..........................................................................................27-344.3.1: setup()................................................................................................27-28
4.3.1.1: inicializaPantalla()...................................................................284.3.1.2: inicializaSD()...........................................................................284.3.1.3: creaFichero().............................................................................28
1
4.3.2: loop()................................................................................................28-344.3.2.1: tratamientoMuestra()..............................................................294.3.2.2: impresionMuestra(lecturaSensor)......................................29-304.3.2.3: guardarMuestra(lecturaSensor)...............................................304.3.2.4: leeValorSensor().................................................................30-314.3.2.5: convertirValor(int)...................................................................314.3.2.6: magnitud(lecturaSensor)..........................................................314.3.2.7: Tratamiento de interrupciones............................................31-34
4.3.2.7.1: mantener()..........................................................................324.3.2.7.2: unidades()..........................................................................324.3.2.7.3: iluminacion()................................................................32-334.3.2.7.4: rangos()..............................................................................334.3.2.7.5: maximominimo()...............................................................334.3.2.7.6: extraerConSeguridad().......................................................334.3.2.7.7: borrado()............................................................................344.3.2.7.8: borradoInformacion()........................................................34
4.4: Montaje del dispositivo....................................................................34-374.4.1: Preparativos para el montaje del dispositivo...................................34-36
4.4.1.1: Realizar perforaciones............................................................354.4.1.2: Soldado de la botonera, pines extra y sensor hall A1318........35
4.4.2: Colocación y conexionado de los componentes....................................364.4.3: Cierre y comprobación del acabado.................................................36-374.4.4: Carga del archivo fuente a la placa Arduino Due..................................37
Capítulo 5: Comprobación.................................................................................38-395.1: Pruebas caja blanca y caja negra...........................................................385.2: Comprobación con otro Teslametro.................................................38-39
Capítulo 6: Presupuesto......................................................................................40-436.1: Diagrama de Gannt................................................................................406.2: Presupuesto del hardware......................................................................416.3: Presupuesto del software.......................................................................426.4: Comparación con un Teslámetro comercial..........................................43
Capítulo 7: Resultados y conclusiones...............................................................44-467.1: Problemas y contratiempos...................................................................447.2: Experiencias y valoraciones del trabajo realizado................................457.3: Ampliaciones...................................................................................45-467.4: Conclusiones.........................................................................................46
Bibliografía..........................................................................................................47-49
Apéndice..............................................................................................................50-61 Código fuente........................................................................................50-61
2
Índice de figuras
Figuras del capítulo 2 . Figura 2.1: Definición magnetómetro........................................................4 Figura 2.2: Teslámetro comercial...............................................................4 Figura 2.3: Efecto Hall................................................................................5 Figura 2.4:Arduino Due.............................................................................10 Figura 2.5: Mapa de los pines de la placa Arduino Due.......................10 Figura 2.6: Descripción de los pines del display LCD...........................11 Figura 2.7: Display LCD............................................................................12 Figura 2.8: Adalloger Feathuring.............................................................13 Figura 2.9: Sensor Hall A1318..................................................................14
Figuras del capítulo 3 . Figura 3.1: Diagrama de flujo principal....................................................15 Figura 3.2: Diagrama de flujo del tratamiento de las muestras.............16 Figura 3.3: Diagrama de flujo de la impresión de las muestras por el
display..............................................................................................................17 Figura 3.4: Diagrama de flujo de guardado de las muestra...................18 Figura 3.5: Diagrama de flujo de lectura de las muestras......................19 Figura 3.6.1:Máximo rango de medida......................................................20 Figura 3.6.2: Ecuación de adecuación de la señal...................................20 Figura 3.7: Diagrama de flujo de la ecuación de adecuación...............20 Figura 3.8: Diagrama de flujo de la magnitud.........................................21 Figura 3.9: Diagrama de conexionado del dispositivo..........................22 Figura 3.10: Componentes del Teslametro con Arduino........................24
Figuras del capítulo 4 . Figura 4.1: Estructura de la lectura de una muestras..............................25 Figura 4.2: Reciclado y deformación de cilindros de plástico para porta-
tornillos............................................................................................................34 Figura 4.3: Componentes con tornillos y porta tornillos..........................35 Figura 4.4: Caja acabada y circuito de conexionado montado...............36 Figura 4.5: Teslametro con Arduino y reciclaje de desechos platico.....37
1
Figuras del capítulo 5 . Figura 5.1: Gráfica comparativa teslametros midiendo una bobina.......39 Figura 5.2: Gráfica comparativa teslametros midiendo un imán............39
Figuras del capítulo 6 . Figura 6.1: Planificación temporal para la realización del proyecto......40
2
Índice de tablas
• Tablas del capítulo 2 .• Tabla 2.3.2: Comparativa sensores Hall.............................................................8
• Tablas del capítulo 6 .• Tabla 6.1: Presupuesto hardware de cada dispositivo.....................................41• Tabla 6.2: Presupuesto software de la elaboración del proyecto....................42• Tabla 6.3:Comparativa teslametros................................................................43
1
Capitulo 1 : IntroducciónEn este trabajo vamos a aproximarnos a la fabricación de un Teslámetro. Intentado quesea fácil de montar, programar y reparar, destinado al uso educativo en los laboratoriosde física de la ETSINF.
1.1 Motivación
Con la aparición del hardware libre o hardware abierto, se ha dado una puerta aldesarrollo de instrumentación de laboratorio. Donde a partir de diseños libres, se puedeir creando distintos aparatos como Teslametros, Voltímetros, Amperímetros, Generadorde señales, Osciloscopios, Brazos robots, Impresoras 3D... con los cuales promulgar lainvestigación científica de un coste mucho más asequible para estudiantes yemprendedores. Como al mismo tiempo aporta una capacidad creativa de adaptación delos instrumentos elaborados a las necesidades particulares de cada persona.
Es evidente que no alcanzan la precisión y estabilidad que los equipos diseñadosindustrialmente, ni tampoco se pretende la suplantación de la industrial productora deestos dispositivos. Solo aportar dispositivos para aquellos que no pueden permitirseuno privado con un elevado coste y promover la reutilización de desechos para elmontaje final de los dispositivos.
1.2 Objetivos
1. Diseñar e implementar un Teslametro de bajo coste para su uso en un
laboratorio de física.
2. Utilizar software libre basado en el sistema Arduino.
3. Utilizar hardware libre basado en el sistema Arduino.
4. Reciclar materiales en su construcción.
5. Verificar su correcto funcionamiento.
1
1.3 Estructura de la memoria
Con un total de siete capítulos, nos adentramos en el diseño e implementación de unMagnetómetro. En este apartado se comentara brevemente el contenido de cadacapítulo.
• Capitulo 1, Introducción: Definimos la motivación y objetivos del trabajo, juntocon la descripción del contenido del trabajo y el uso de la bibliografía más destacada.
• Capitulo 2, Análisis: Estudiamos los Teslametros típicos del mercado, para laextracción del funcionamiento y de los requerimientos mínimos de hardware, comoademás plantear los requerimientos personalizados para el laboratorio. Búsqueda decomponentes y comparativas entre similares y por último una descripción de loscomponentes seleccionados.
• Capitulo 3, Diseño: En este capitulo nos centramos en el diseño lógico delMagnetómetro realizando diagramas de flujo, y del diseño hardware, distinguiendolas distintas conexiones como los buses utilizados, y su caja de montaje junto con elprocedimiento de alimentación del dispositivo.
• Capitulo 4, Implementación: Durante este capitulo nos centramos en eldesarrollo del dispositivo, incluyendo explicaciones de las implementacionessoftware realizadas y del montaje final en la caja.
• Capitulo 5, Comprobación: Comprobamos cada una de las conexiones, cadauno de los flujos de datos, y de correcta medición del campo magnético.
• Capitulo 6, Presupuesto: Contabilizamos el precio de los componentes y eltiempo empleado en el desarrollo de la aplicación mediante diagramas de Gannt.Además procederemos a comparar el dispositivo resultante con distintos Teslametroscomerciales.
• Capitulo 7, Resultados y conclusiones: Este último capitulo describe losproblemas y dificultades encontradas durante el desarrollo del dispositivo ysugerencias de ampliación del dispositivo y del trabajo.
Cabe destacar la existencia de varios anexos en el documento, como son la bibliografíautilizada y el código resultante del Teslametro.
2
1.4 Uso bibliográfico
En este apartado vamos a explicar del material bibliográfico utilizado para elaborar elproyecto.
• En primera instancia empleamos los recursos de la Efecto Hall [13], RAE [14],Magnetómetro [16] y Wikipedia [17] para introducirnos en los Teslámetro, y asípoder analizarlos.
• Una vez clara la idea de los magnetómetros, procederemos a buscar dispositivos conlos que confeccionar el proyecto. Para ello empleamos los recursos Arduino [7] yRsComponentes [15].
• Habiendo escogido los componentes, necesitamos información acerca de ellos y sufuncionamiento. Para ello recurrimos a los recursos de Adafruit RTCLib [1],Arduino AnalogReadResolution [2], Arduino Due [3], Arduino Forum fat16lib [4],Arduino HallEfect [5], Arduino LiquidCrystal [6], Arduino SD [8], Arduino SPI [9]y Arduino Wire [10]. En estos recursos es consultada toda la información necesariapara entender el funcionamiento de los distintos componentes y de comoensamblarlos todos para componer el dispositivo.
• Por último, para dar precio a las horas dedicadas al trabajo y aproximarnos almundo laboral, damos uso al recurso del Boletín oficial del estado [11]. En eldocumento oficial del estado queda declarado el sueldo mínimo correspondiente conlos distintos trabajos relacionados con la consultoría informática.
3
Capitulo 2 : Análisis
Durante el segundo capitulo se va a proceder a investigar y analizar el funcionamientode un Teslámetro. Procederemos a buscar los Teslametros existentes en el mercado,extraeremos los requerimientos hardware, y procederemos a buscar y seleccionar loscomponentes necesarios para el desarrollo del dispositivo.
2.1 Introducción a los Teslámetros
A continuación, realizaremos una aproximación a los dispositivos de medición delcampo magnético. Primero analizamos un poco más su significado, para ellorecurrimos a la real academia de la lengua española, en ella descubrimos queTeslámetro no existe como tal, la palabra oficial en la lengua castellana esMagnetómetro y su significado lo podemos ver en la Figura 2.1.
4
Magnetómetro: Aparato que mide la inducción de un campo magnético en una dirección determinada
Figura 2.1: Definición magnetómetro
Figura 2.2: Teslámetro comercial
Un magnetómetro básico como el de la Figura 2.2, dispone de una display LCD, unainterfaz de usuario, y una sonda de medición o sensor.
Siguiendo con la introducción en la medición de los campos magnéticos, vamos apreguntarnos por que tipos de sensores existen para la medición de ese campo.Indagando un poco, encontramos que la gran mayoría de sensores de medición decampos magnéticos se basan en el efecto Hall1.
1 El efecto Hall se produce cuando se ejerce un campo magnético transversal sobre un cable por elque circulan cargas. Como la fuerza magnética ejercida sobre ellas es perpendicular al campomagnético y a su velocidad según la ley de Lorentz, las cargas son impulsadas hacia un lado delconductor y se genera en él un voltaje transversal o voltaje Hall.
5
Entre ellos podemos destacar los escalares que miden la fuerza en una única direccióndel vector B de campo magnético al que son sometidos; y los vectoriales que tienen lacapacidad de medir todas las componentes del vector del campo, concretamente lascomponentes (X,Y, Z).
Figura 2.3: Efecto Hall
2.2 Requerimientos del dispositivo
En este apartado vamos a describir que necesidades presenta un Magnetómetro básico,como el de la Figura 2.2. Para ello nos valemos de uno convencional y le añadimosrequisitos que creamos convenientes para nuestro magnetómetro, como es elalmacenamiento de la información captada.
Leyendo un poco sobre el tema, podemos definir como común; una pantalla por la queimprimir la información, una botonera de interfaz de usuario y un sensor Hall.
Naturalmente nuestro dispositivo no es una copia simple de los Magnetómetros máseconómicos, al considerar de forma propia los requisitos del Magnetómetro quenecesitamos, además de los requisitos observados en los Magnetómetro comerciales,vemos conveniente un almacenamiento de la información de forma detallada yordenada; con fecha y hora de las medidas tomadas, para permitir una fácil forma deextracción de datos para gráficas.
6
2.3 Selección dispositivos
Sabiendo nuestras necesidades, es momento de tomar decisiones respecto a comoplantearnos el dispositivo.
Primera decisión a tomar es la forma que utilizamos para imprimir la información. Paraello podemos disponer de la comunicación con un PC y aprovechar su pantalla; ointegrar una pantalla ligera en el dispositivo. La ausencia de una pantalla integrada en eldispositivo impide que este dispositivo sea portátil, mientras que con una pantallaintegrada nos permite desplazarnos donde queramos fácilmente y sin necesidad de unPC.
Definitivamente optamos por integrar una pantalla en el dispositivo. Ahora hay quedecidir que tipo de pantalla integramos. En este caso, vamos a considerar cuantainformación disponemos para imprimir. Donde recae otra decisión, que sensor Hallvamos a escoger, decidimos utilizar un sensor Hall escalar o lineal con una únicamedida, esta decisión se comenta más a fondo en el Capitulo 2.3.3.
En conclusión, como tenemos poca información respecto al muestreo, es un valor juntoa su unidad y la polaridad de la muestra. Entonces con una pantalla simple es suficiente,y entre otras los display LCD, son económicos, y bastante útiles para representarvalores y caracteres.
Otra decisión a tener en cuenta es como implementar la interfaz de usuario. Esta vienecondicionada por la primera decisión de como imprimir la información, por el hecho deque en esa decisión escogimos integrar la pantalla para poder prescindir de un PC ootros.
Por ello, siguiendo con el mismo razonamiento, nos vemos obligados a escoger unabotonera física integrada en el dispositivo, más adelante explicaremos con másdetenimiento las distintas tomas de decisión que surgen a consecuencia de esta última,concretamente en el Capitulo 2.4.6
Respecto al almacenamiento de la información recogida, se cree conveniente el uso detarjetas microSD; debido a que tienen un uso muy extendido y son económicas; y nospermiten un almacenamiento integrado en el dispositivo siguiendo los patronesanteriormente escogidos.
Para la placa controladora de los distintos dispositivos, escogemos las placas deArduino, siendo un requerimiento del proyecto además de su vinculación con el mundouniversitario, su licencia, y su bajo coste.
Arduino tiene licencia open-source, se programa con Arduino Programming Language,dispone de interfaz propia (Arduino Development Enviorement). Conformando unaplaca de prototipos electrónicos flexible y fácil de usar aunque puede llegar a usarse sin
7
la interfaz y su lenguaje de programación, utilizando por tanto C++ y aumentado ladificultad al uso pero ampliando la profundidad de comprensión en su funcionamiento.
Con una breve historia, dispone de una larga documentación y módulos compatibles,una gran parte contribuyen con la fundación Arduino, aunque hay muchos otros queson compatibles que no lo hacen, con esta historia hay mucha controversia en la cualno nos inmiscuiremos, aunque en este proyecto tendremos en cuenta a aquellos que sicontribuyen con la fundación Arduino. Seguidamente analizaremos brevemente lasplacas existentes de Arduino y seleccionaremos aquella que más se adecue al proyecto.
2.3.1 Comparativa Arduinos
Existen varias placas con distintas prestaciones, intentando adaptarse a cierto tipo deaplicaciones. Las más comunes son Arduino UNO, Arduino Mega, Arduino Mini,Arduino Nano, Arduino Leonardo,Arduino Due. Existen otras menos comunes comoArduino Lili, Arduino Fio o Arduino Pro Mini.
De entre los más comunes, muchos de ellos tienen un número bajo de pines comoArduino Uno, Arduino Leonardo, Arduino Mini, Arduino Nano, los cuales nos sirvenpara este proyecto, pero están un poco limitadas para hacer ampliaciones y además nosquedamos un poco cortos con las capacidades de interrupciones hardware, que solodispone de 2. Mientras que Arduino Mega y Arduino Due dispone de 6 con los pinesfijos para la Mega, pero para la Due cualquier pin Digital puede ser configurado comointerrupción. Todo esto podemos observarlo en la Tabla 2.3.1
Así que tenemos como posible candidatas Arduino Mega y Arduino Due, ambas sirvenpara nuestro propósito. Para este proyecto hemos decidido usar Arduino Due, porquedispone de más frecuencia de reloj, de una resolución de 12 bits en sus conversoresanalógico-digital, permitiéndonos una mejor precisión de medida del campo.
Aunque nos plateemos usar Arduino Due por posibles ampliaciones, debemos tener encuenta que Arduino Mega también se puede usar y se programara el código defuncionamiento para que sea compatible con ella.
2.3.2 Comparativa Sensores Hall
Hemos de tener en cuenta, que este sensor va a ser el encargado de percibir el campomagnético. Por tanto cuanto mas sensibilidad posea el sensor más precisas serán lasmuestras obtenidas en las unidades estándares de medición (Tesla y Gauss), perotambién nos interesa tener un rango de medida de al menos 200 mT [-100 mT, 100mT].
Existen distintos tipos de sensores Hall (escalares, vectoriales). Para una primeraaproximación a los Magnetómetros básicos, nos centraremos en escoger sensoresescalares, son económicos y simples, miden en un eje pudiendo llegar a medir una delas componentes del vector B de campo magnético al que es sometidos dependiendo
8
del ángulo en el cual se realice la medida. Los sensores Hall vectoriales también soneconómicos, sencillos, y miden los tres ejes. A pesar de ello es más convenienteemplearlos en futuras ampliaciones del Magnetómetro y así desarrollar uno avanzado.
Teniendo en cuenta que vamos a utilizar una Arduino Due que funciona a 3,3Vnecesitamos un sensor que trabaje a esa tensión. Muchos trabajan por encima de los 3V, así que estamos un poco limitados. Aunque en el caso de usar Arduino Megatendríamos bastante más gama a elegir.
Sensor Hall Vcc min Vcc max Sensitivity
A1318 3 V 3,63 V 1,2-1,4 mv/G
AH49E 3 V 6,5 V 1,1-2,1 mv/G
TSH481 3 V 6,5 V 1,8-2,2 mv/G
Tabla 2.3.2: Comparativa sensores Hall
Hay más opciones a escoger, pero estos tres modelos son los que ofrecían unasensibilidad adecuada para nuestro proyecto. Y como elección final tomamos el A1318que dispone un voltaje máximo más próximo al máximo de los pines de Arduino Due,de este modo aseguramos el correcto funcionamiento del sensor, ja que los otros dosnecesitan el doble de la proporcionada por los pines de Arduino Due.
Por lo tanto con el sensor Hall A1318, tenemos un rango entre [-128 mT, 128 mT], conuna sensibilidad de 0,5 mT / b. Mientras que el AH49E tiene [-103,25 mT, 103,25 mT],con un sensibilidad de 0,4 mT / b. Y TSH481 tiene [9-1 mT, 91 mT] con 0,35 mT/b.
2.3.3 Comparativa SD/MicroSD
Para finalizar las comparativas, hablaremos un poco sobre las tarjetas SD y lasmicroSD. Aunque a primera vista parezcan iguales pero distintas en tamaño, ocultanotras pequeñas diferencias. Existen distintos tipos de estas tarjetas, SD, SDHC y lasSDXC. Además de distintas clases (2, 4, 6 y 10). Cada una tiene unas propiedadesdistintas de capacidad y velocidad de transmisión.
Arduino accede a las tarjetas utilizando el bus SPI a una velocidad máxima de 8 MHzsin acceso dinámico de memoria (DMA), por lo que nunca obtendrá una velocidad detransferencia superior a unos 500 KB/seg, aproximadamente la mitad de la velocidad
9
del bus estándar. En la práctica la velocidad de lectura máxima de un archivo es deaproximadamente de 300 KB/ seg.
La mayoría de PC's, Macs o otros dispositivos acceden a las tarjetas usando el bus auna frecuencia de reloj de hasta 50 MHz y el bus es de 4 bits de ancho de banda por loque es posible una tasa de lectura de 25 MB/seg. Las tarjetas nuevas utilizan el busUHS-1 que alcanza los 104MB/seg.
De esta manera las tarjetas que no entren dentro de lo anteriormente comentado nofuncionaran en Arduino y por tanto estamos limitados a las tarjetas SD por suscaracterísticas, las SDHC y SDXC no son soportadas.
2.4 Introducción a Arduino y los módulos seleccionados
Se va a proceder a presentar brevemente los dispositivos y módulos seleccionados y sufuncionamiento típico.
2.4.1 Arduino Due
Arduino Due es una variante de Arduino con un procesador ARM CortexM3 de 32 bits,programables desde la interfaz de Arduino, con una frecuencia de funcionamiento de84MHz, a 3,3V de tensión de funcionamiento.
Dispone de 12 entradas analógico-digital, 2 salidas digital-analógico, 54 entras/salidasdigitales de los cuales todos se pueden configurar como interrupción hardware con untotal de 6 interrupciones (INT0, INT1, INT2, INT3, INT4, INT5). Posee una conexiónUSB-OTG, conector SPI, 2 puertos para conexión I2C, 4 puertos Serie, además delpuerto USB Nativo, ISCP, un encabezado Jtag y Debug. Dos botones, uno es el reset yotro de borrado EEPROM.
Este modelo es perfecto para dispositivos de laboratorio debido a su alta sensibilidad ensus pines analógicos y alta frecuencia de funcionamiento.
10
Figura 2.4: Arduino Due
Figura 2.5: Mapa de los pines de la placa Arduino Due
11
2.4.2 Display LCD
El display monocromado retroiluminado con una matriz de 16 columnas y 2 filas, es económico y suficiente para mostrar la información de las muestras recogidas por el sensor.
Funciona a 5V y dispone de 16 pines para su funcionamiento.
Figura 2.6: Descripción de los pines del display LCD
Se va a conectar mediante el modo 4 pines, donde los pines 11, 12, 13 y 14 van atransmitir datos. Esta forma de funcionamiento es muy rápida y nos permite podertener una alta tasa de refresco del display. Se podrían usar otros buses, como porejemplo con un bus I2C con el que tendríamos una sensación de retardo para tan solodos conexiones menos, mientras que con el modo 8 pines, duplicaríamos el cableadopara la transmisión pero no mejoraríamos las prestaciones ya que no necesitamos tantoni tampoco disponemos de un display muy grande.
Además hacemos uso de la librería LiquidCrystal para realizar una programación dealto nivel con el fin de controlar el display, sin necesidad de programar a bajo nivel.
12
Figura 2.7: Display LCD
2.4.3 Reloj RTC
Se necesita llevar un registro ordenado temporalmente del registro de muestrasalmacenado en la tarjeta microSD. Como el reloj interno de Arduino se reinicia cadavez que apagamos el dispositivo, necesitamos un reloj externo con batería propia. Paraello disponemos de los relojes RTC.
Echando una ojeada en las tiendas on-line de los productores oficiales de hardwarecompatible con la fundación Arduino, encontramos un módulo de Adaloger FeatherRTC y microSD, integrados en la misma placa; nos proporciona una doble solución anuestro proyecto.
El reloj RTC funciona a 3V y utiliza el bus I2C para comunicarse con la placa Arduino.Se utiliza la librería RTClib para su programación.
13
Figura 2.8: Adalloger Feathuring
2.4.4 Lector Targetas MicroSD
Como se ha comentado en el apartado anterior, el módulo lector de tarjetas microSDseleccionado es el Adaloger Feather , utiliza el bus SPI para conectarse a la placaArduino, pines MISO, MOSI, SCK se conectan directamente al puerto SPI de laArduino Due, mientras que el ChipSelect (CS) se conecta a los pines digitales.
Se usa la librería SD para su programación a alto nivel.
2.4.5 Sensor Hall
Definitivamente se escoge el sensor Hall A1318 lineal de 1.3 mV/Gauss con conexiónOne-Wire; de los cuales hay muchos fabricantes y se puede elegir cualquiera de ellosque cumpla esas condiciones y sea compatible con Arduino Due.
14
Figura 2.9: Sensor Hall A1318
2.4.6 PCD Botonera interfaz usuario
En este último apartado, desarrollaremos el proceso de elaboración de la botonera deinterfaz de usuario. Debido a que en el mercado existe una variedad limitada debotoneras compatibles con Arduino Due, y ninguna de ellas se adecua a las necesidadesdel proyecto. Por eso la mejor opción es elaborar nosotros mismos la botonera adaptadaa nuestras necesidades.
Para ello con unos botones para circuitos impresos, unas resistencias de 10k Ohmios,un condensador de 6 uF, una PCB perforadora en matriz, para que con un poco deestaño y un soldador poder disponer de nuestra interfaz de usuario para utilizar elMagnetómetro.
Con todo esto conseguimos solucionarlo de una forma muy económica y sencilla dereparar. No dispondrá de unos acabados perfectos para su venta, pero si suficientes parafomentar el aprendizaje y auto-construcción de prototipos.
Además configuraremos los pines correspondientes para que detecten los flancos debajada de los botones y activen cada uno su interrupción correspondiente. Además de laincorporación de un condensador para anular el efecto rebote o debounce de lospulsadores, también se programara un sistema de control mediante la medicióntemporal entre flancos de activación de las interrupciones.
15
Capitulo 3 : Diseño
Durante este capitulo vamos a elaborar el diseño del dispositivo, para elloconfeccionamos un flujo de los datos para orientarnos luego en la implementación delcódigo. También seleccionaremos los pines a los que se conectará cada componente alArduino Due, y por último diseñaremos dentro de la caja la colocación de loscomponentes y comentaremos la alimentación del dispositivo.
3.1 Diagramas de flujo
En este apartado se va a proceder a presentar y explicar los diagramas de flujoconfeccionados para el diseño de un Magnetómetro.
3.1.1 Diagrama principal
Primero analizamos el funcionamiento de básico de la estructura del código de Arduinotípica un método setup() de inicialización, donde configuramos los pines,interrupciones y los módulos LCD, microSD, sensor Hall y el reloj RTC.
Figura 3.1: Diagrama de flujo principal
Seguido del método principal que siempre se repite, loop(). Donde se realiza unalimpieza del display lcd y se invoca a la función tratamientoMuestra, que gestiona todala toma de información, impresión y almacenado de cada muestra tomada.
16
3.1.2 Función tratamientoMuestra
Figura 3.2: Diagrama de flujo del tratamiento de las muestras
Como se puede observar en la Figura 3.2 primero se lee una muestra, luego se examinapor si es máximo o mínimo. Seguidamente dependiendo de la interacción del usuario,se realizara una gestión distinta, si el usuario deseaba mantener la imagen congelada enel display LCD se invocara la función impresionMuestra pasándole como parámetro elvalor a mantener almacenado en la variable correspondiente; por otra parte se invocaríala misma función pero como parámetro la muestra tomada en esa misma iteración delprograma.
Y por último si el usuario no ha extraído la tarjeta microSD se procederá a guardar enella la ultima muestra junto a la hora y día y el máximo y mínimo en ese momento.
17
Hay que observar que se utiliza un tipo de datos llamado lecturaSensor, el cual es unaestructura conformada por 7 elementos significativos de la representación deinformación perteneciente a una lectura del sensor Hall.
3.1.3 Función impresionMuestra
Como ya se ha comentado anteriormente, para la gestión de la impresión por el displayLCD, se invoca la función impresionMuestra(lecturaSensor). Su flujo de datos se puedeobservar en la Figura 3.3
Figura 3.3: Diagrama de flujo de la impresión de las muestras por el display
Aquí, nuevamente, dependiendo de la interacción del usuario, se deberá actuar demanera distinta. Concretamente tenemos dos casos destacables que son, por un lado siel usuario desea ver el máximo y mínimo almacenados o si por el contrario deseaobservar el muestreo del sensor.
En cada uno de los casos, la gestión es similar, se organiza la información en la matrizde 16x2 del display LCD. Inicialmente, se imprimirá el muestreo del sensor, de maneraque en la fila 0 se imprimirá la información relevante a la muestra. Y en la fila 1 semostrara el estado de interacción del usuario con el dispositivo.
En caso de que el usuario solicite el máximo y el mínimo almacenados, se organizarade manera que cada fila muestre la información relevante de cada uno de ellos.
18
3.1.4 Función guardarMuestra
En la Figura 3.4 queda reflejada la gestión de almacenamiento de la informaciónmuestreada en cada iteración del loop principal. De esta manera podremos tener unregistro ordenado del uso del Magnetómetro.
Para ello, se utiliza la función guardarMuestra, que es invocada pasándole unaestructura lecturaSensor como parámetro. Esta función abre el archivo datos.txt, si noha habido error, prepara en una variable la información ordenadamente para guardarlaen la microSD.
Figura 3.4: Diagrama de flujo de guardado de las muestras
Además se ha preparado un botón de la interfaz, para extraer con seguridad la tarjetamicroSD, de manera que cuando se solicita su extracción deja de invocar a la funciónguardarMuestra.
De esta manera garantizamos que al extraer la tarjeta no lo haremos en medio de unalmacenado de muestra, ja que eso podría causar daños a la información del archivo deregistro.
19
3.1.5 Función leeValorSensor
Figura 3.5: Diagrama de flujo de la lectura de una muestra
Hemos planteado la impresión y el almacenado de la información, ahora nos toca unpunto por el cual no podrían funcionar los anteriores, el tratamiento de la señal obtenidadel sensor Hall.
En este proceso están involucradas 3 funciones. La primera de ellas leeValorSensor, nonecesita parámetros de entrada y devuelve una instancia del tipo lecturaSensor, recopilay organiza los 7 datos necesarios para crear la nueva instancia. Para ello necesita laayuda de las otras 2 funciones, convertirValor y magnitud, que se explicaran acontinuación.
3.1.6 Función convertirValor
Esta función necesita un entero como parámetro de entrada, que es la lectura del pinanalógico al que esta conectado el sensor Hall. Además devuelve un double resultadode aplicar una ecuación de acondicionamiento de la señal proporcionada.
Como se observa en Figura 3.7, diferenciamos entre las muestras tomadas en Tesla o enGauss, permitiendo poder tener mayor versatilidad de magnitudes, consiguiendo así T,mT, uT, kG, G y mG.
La ecuación de acondicionamiento consiste en acotar el rango de medida, sabiendo quetenemos 1.3 mV por cada 1G de variación en el sensor, que Arduino Due dispone dehasta 3300 mV, y que el sensor tiene una tensión de 1,62 V cuando el campo magnéticocaptado es nulo. Operamos para calcular el rango máximo de medida del sensor A1318:
20
Figura 3.6.1: Máximo rango de medida
Sabiendo que el valor 0 del campo magnético corresponde a una tensión de 1,62 V,sabemos que los valores negativos del campo magnético oscilaran entre 0 V a 1,62V ylos valores positivos de 1,62 V a 3,3 V. Habiendo calculado el valor máximo quepodemos captar con el sensor, si este resultado le una ecuación de adaptación para elrango de medida de [-126,923 mT, 126,923 mT]. Observamos que el valor captado enla entrada analógica de Arduino Due varia entre [0, 1024], este valor hay que adaptarloal rango de [-126,923 mT, 126,923 mT]. Para ello operamos y al generalizarobtenemos:
Figura 3.6.2: Ecuación de adecuación de la señal
Donde valor es la lectura de la entrada analógica de la placa Arduino Due, Vmax es la tensiónmáxima de la placa Arduino Due (3300 mV), Vsensor es la tensión por cada Gauss dada de cadasensor hall; en nuestro caso el sensor hall A1318 tiene 1,3 mV/G. Resolución es el total de bitsutilizados por el sensor y la placa Arduino Due para la representación de la señal analógicatransmitida.
Figura 3.7: Diagrama de flujo de la aplicación de la ecuación de adecuación
21
3300 mV ×1 G
1,3 mV×
1mT10G
=3300mT
1,3⋅10=253,846 mT
valor×(
(Vmax×1G×1mT
Vsensor×10 G)
resolucion)−
Vmax×1G×1 mTVsensor×10G×2
En la figura 3.7, vemos el procedimiento seguido para convertir el valor leído al rangode medida adecuado. Además teniendo en cuenta en la unidad de medida en la cual seesta solicitando las muestras por parte del usuario.
3.1.7 Función magnitud
Figura 3.8: Diagrama de flujo de la representación de la magnitud medida.
Como podemos observar en la Figura 3.8, la función magnitud analiza el estado de lavariable unidad de la lecturaSensor recibida por parámetro, esta dependiendo de suvalor nos indica si esta medida en Tesla o en Gauss, luego comprueba el rango de lalecturaSensor para determinar el símbolo final que se asignara a la propia lecturaSensoren la variable magnitud.
22
3.2 Conexionado de los componentes
En este apartado plantaremos la interconexión de componentes y definiremos los pinesde la placa de Arduino Due que tendrán los correspondientes buses de comunicacióncon los periféricos. Y al mismo tiempo definir en cada periférico en que pines seconecta a la placa.
Primero observemos la Figura 3.9, donde queda reflejado la interconexión de loscomponentes.
Figura 3.9: Diagrama de conexionado del dispositivo
Algunos de los módulos representados no son los mismos que el montaje final, perocumplen sus misma características de funcionamiento e interconexión.
● Display LCD 4 pin
Utiliza los pines 8(pin 4 del display),9(pin 6 del display), 4-7(pines 11-13 deldisplay); de la placa de Arduino Due.
Mientras que además tiene un potenciómetro de 50k Ohmios conectado al pin3 del display, el resto de conexiones se realizan según la Figura 2.4.2.
23
● Reloj RTC I2C
Al utilizar el bus I2C, utiliza un pin para reloj(SCL) y otro para datos(SDA). Seha decidido utilizar los puertos de la placa Arduino dedicados al segundo busI2C implementado, SCL1 y SDA1; el resto de conexiones son simplemente laalimentación del modulo como queda reflejado en la Figura 2.4.
● Lector MicroSD SPI
El bus más eficiente para comunicarse con un modulo microSD queimplementa Arduino, es el bus SPI, que utiliza 4 pines, CS (chipSelect), SCK(reloj), MISO (Master-IN, Slave-OUT), MOSI ( Master-OUT, Master-IN ), quedispone de pines propios en el centro de la placa. Por ello hace que Arduinosolo sea capaz de leer tarjetas sd1 y sd2, ya que las sdh necesitan un puerto demayor velocidad llamado USH.
● Sensor Hall One-Wire
Se ha decidido utilizar un sensor con bus One-Wire, porque al ser un sensorlineal, su simplicidad permite que con el bus One-Wire tengamos junto con laalta frecuencia de procesamiento que nos ofrece Arduino Due, obtenemos unaalta tasa de muestreo al que solo hay que aplicar una sencilla transformaciónque no ralentiza al sistema.
Además de que reducimos el numero de cables y pines en uso de la placaArduino Due pudiendo aceptar ampliaciones en un futuro.
Al ser una señal analógica se conectara al puerto analógico-digital 0 de la placaArduino Due.
● Botonera interfaz usuario
Como ya se ha comentado anteriormente en el Capitulo 2.4.6, la botoneraconsistirá en un circuito eléctrico de una serie de pulsadores en pull-down,donde cada uno estará conectado a un pin de la placa Arduino donde detectarala interacción del usuario con la interfaz y disparar las interrupcionescorrespondientes.
En un total de 6 pulsadores, accionando las interrupciones de HOLD(mantener)pin 20, LIGHT(iluminación) para la ArduinoMega o CALIBRA(calibrado) parala Arduino Due; pin 19, UNITS(units) pin 18, RANGE(rango) pin 3,MAX/MIN(máximo/mínimo) pin 21, EXTRACT(extracción segura microSD)pin 2. En este dispositivo vamos a encontrar un efecto físico en los pulsadoresdenominado debounce o retardo, consiste en la estabilización de la señal alcambiar de flanco, la cual produce unos instantes en que la señal oscila entre 0
24
y 3,3V, pudiendo activar nuevas interrupciones sin que sean realmentesolicitadas por el usuario.
3.3 Revestimiento y alimentación
En este apartado vamos a centrarnos en la caja para el montaje definitivo, y comoalimentaremos el dispositivo.
A lo que la caja respecta hemos decidido construir nosotros mismo la caja dondemontar el dispositivo. Reutilizaremos algún tupper-ware o caja de plástico, quevallamos a desechar, suficientemente grande para abarcar nuestros dispositivos ycableado. De esta manera fomentamos la creación de prototipos caseros y una toma decontacto con la reutilización de los desechos plásticos en nuestros proyectos,consiguiendo darle uso a muchos desechos que se generan en el día a día en los hogaresy que acaban en vertederos, así conseguimos alargar la vida útil de ciertos desechos yincentivando el reciclaje y la reutilización.
Además necesitamos, tornillos, porta-tornillos o fijaciones; para los tornillos podemosvalernos de hardware en desuso, tal como lectores de cd, disqueteras, o discos durosrotos. Para la fijación de los tornillos en la caja, podemos utilizar tacos de plástico parafijar modificaciones con calor conseguimos fácilmente unos porta-tornillos robustos.
El proceso de montaje se describirá detalladamente más adelante en Capitulo 4., perobrevemente consistirá en seleccionar la ubicación de los componentes, realizar loscortes y perforaciones necesarios para dejar el sitio de los componentes, colocar unosporta-tornillos donde fijar los componentes a la caja. Todo esto realizado con unsoldador de estaño, regla, lápiz y una pistola de termo-silicona.
Respecto a la alimentación del dispositivo, dispondremos de dos opciones a usar,dependiendo de las necesidades del momento. Se podrá conectar con un transformadorde 220V a 5 a 7 V, o por contra usar un banco de energía y conectarse mediante elUSB.
25
Figura 3.10: Componentes del Teslametro con Arduino
Capitulo 4 : Implementación
En este cuarto capitulo vamos a implementar los diseños realizados en el capitulo anterior.Para ello separamos la estructura de datos utilizada para datos del sensor, las libreríasutilizadas, las funciones de flujo de datos y el montaje del dispositivo en la caja.
4.1 Estructura de datos lecturaSensor
Debido a la necesidad de transferir fácilmente la información de las lecturas del sensorentre las distintas funciones, se ha decidido agruparla toda ella en una estructura.
struct lecturaSensor { int valorOriginal;
double valor;String polaridad;int rango;
boolean unidad; String magnitud;
DateTime fechaYHora; };
Figura 4.1: Estructura de la lectura de muestras
Esta estructura consiste en el almacenamiento de información relativa a las lecturastomadas del sensor Hall.
Tales como, el valorOriginal, un entero usado para comprobar si son máximos omínimos; el valor convertido a Tesla o Gaus con un double, la polaridad del campomagnético en un String, la unidad utilizada mediante un boolean T true o G false, elrango indicado mediante un entero que varia entre T un 0, mT un 1, uT un 2 y igualpara KG, G, mG; el String de la magnitud utilizada en la medición y por último la fechay hora con un DateTime.
26
4.2 Librerías utilizadas
Durante el siguiente apartado vamos a presentar a las librerías empleadas en eldesarrollo del software.
4.2.1 LiquidCrytal
Esta librería permite a la placa Arduino Due controlo el diplay LCD. La librería trabajaen el modo 4 o 8 bit.
Para trabajar con ella se crea una variable global del tipo LiquidCrystal e invocando alconstructor de la clase que nos convenga. Existen 4 que son :
• LiquidCrystal(rs, enable, d4, d5, d6, d7)
• LiquidCrystal(rs, rw, enable, d4, d5, d6, d7)
• LiquidCrystal(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7)
• LiquidCrystal(rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7)
En ellos podemos observar las variables que guardan relación con los pines del displayplanteados en el capitulo 2.4.2. El primero de ellos activa el display en modo 4 bit yademás solo lectura, el segundo es con lectura y escritura. Del mismo modo para eltercero y cuarto, pero estos para el modo 8 bit.
Además dispone de otras funciones, como begin(), clear(), setCursor(), print(), cursor(),leftToRight(), entre otros. Todo esto esta disponible en la pagina web de Arduino.
4.2.2 SPI y SD
La librería SPI, consiste en una clase de control del bus SPI (Serial PeripheralInterface) el cual sigue el protocolo de conexión serie síncrona. Este bus es utilizadopor la tarjeta SD, para comunicarse con la placa Arduino Due. La librería SD habilita elbus utilizando la librería SPI, y invocando las funciones de la librería SD controlamosel modulo de la tarjeta micro SD. de esta manera lee y escribimos en los archivosalmacenados en la micro SD.
La librería SD dispone de varias clases de las cuales obtiene distinta información yfuncionamiento. Esas clases son File, SDClass, Sd2Card y SdVolumen, entre otras. Laclase File es usada para lee y escribir archivos almacenados; con Sd2Card ySdVolumen obtenemos información de la tarjeta insertada en el modulo. Y con laSDClass obtenemos una instancia llamada SD, con la que invocar las funciones quenos permiten abrir los archivos que almacenaremos en la variables del tipo File.
Todo esto puede consultarse en la pagina de Arduino.
27
4.2.3 Wire y RtcLib
Estas librerías son utilizadas para el funcionamiento del dispositivo del reloj RTC, enconcreto la librería Wire es utilizada por la librería RTClib para usar el bus I2C o TWI,al igual como pasa con la librería SPI y SD.
El bus en este caso esta formado por dos conexiones, una de datos(SDA) y otra desincronización (SCL). Es un protocolo asíncrono, SCL indica cuando leer los datos.Cada dispositivo conectado al bus tiene una dirección de 7 bits con lo que se puedenconectar hasta 128 dispositivos en paralelo (2 ). Entre ellos debe haber uno o más⁷maestros que controlan el reloj, pudiendo estar solo uno activo a la vez. Y el resto dedispositivos son esclavos.
La librería RTClib, es una librería de Adafruit, disponible en el GitHub de Adafruit.Esta incluye las clases DateTime, TimeSpan,RTC_DS1307, RTC_DS3231,RTC_PCF8523, RTC_Millis. Para su uso, creamos una variable global de la claseRTC_Millis; de la cual se tomara la fecha y la hora almacenadas en el modulo RTC. Seguardara en una variable de la clase DateTime. La librería se encarga de activar el busI2C, establecer el maestro y los esclavos, en nuestro caso solo al modulo RTC; yrealizar las comunicaciones a través de él.
4.3 Funciones
A continuación presentaremos la implementación de las funciones pertenecientes a losdiagramas de flujo de datos realizados previamente. Están dividas dentro de donde sonutilizadas, es decir, los programas en Arduino se componen del setup() y del loop(), ypueden haber más funciones pero solo van a poder ser invocadas dentro de los dosanteriores .
Por tanto están divididas entre las que son invocadas en el setup() y las que soninvocadas en el loop().
4.3.1 setup()
En el transcurso del dispositivo, lo primero que realizamos es la inicialización y elestablecimiento de los pines y las interrupciones.
Primero inicializamos los pines mediante pinMode(nºPin, Mode), donde indicamos elnumero del pin y si actuara como INPUT o OUTPUT. En total inicializamos 7 pines deesta manera; uno para cada botón y uno para la conexión de alimentación de lailuminación de la pantalla LCD.
Posteriormente, configuramos las interrupciones mediante:
attachInterrupt( digitalPinToInterrupt(nºPin), función de tratamiento, flanco de detección );
28
Donde indicamos el pin mediante una conversión a pines de interrupción condigitalPinToInterrupt() . Luego el nombre de la función de tratamiento donde ejecutaralas acciones previstas para esa interrupción y el flanco de detección de la interrupción.
Luego se invocan 3 funciones escritas fuera del bloque del setup(), para juntar en cadauna los procesos de inicialización de los distintos componentes.
4.3.1.1 inicializaPantalla()
El display LCD, es inicializado mediante la instrucción lcd.begin(16, 2);. donde lcd esuna instancia de la clase LiquidCrystal declarada anteriormente a la invocación de lainstrucción de inicialización; LiquidCrystal lcd(8, 9, 4, 5, 6, 7); indicando los pinesutilizados para su conexionado, explicados anteriormente en el capitulo 3.2 DisplayLCD 4 pin. Por último se invoca lcd.clear(); para limpiar alguna posible impresiónanterior.
4.3.1.2 inicializaSD()
Mientras que para el lector de tarjetas microSD, se inicializa el modulo medianteSD.begin(chipSelect), si esto falla se guarda el error en la variable iniSd, dejándola enfalse, por el contrario si se inicializa correctamente se pone a true indicando que hayuna tarjeta insertada en el modulo.
Además inicializamos otro modo de la tarjeta, card.init(SPI_HALF_SPEED, CS)activando una variable tarjeta del tipo Sd2Card, de la cual extraemos informaciónrelevante como su tipo de datos o el tipo de tarjeta SD.
Por último, comprobamos de la existencia del archivo de registro, y si no esta lo creamediante la función creaFichero().
4.3.1.3 creaFichero()
La función creaFichero(), es invocada por las funciones inicializaSD() yborradoInformacion(). Su cometido es de crear el archivo de registro de datos y escribirla fecha y hora de reinicio del archivo.
Para ello instancia una variable del tipo DateTime con valor rtc.now(), de manera quedispone de la fecha y hora de ese momento. Luego abre un archivo conSD.open(nombreFichero, FILE_WRITE) con nombre el String almacenado en lavariables nombreFichero y en modo escritura; escribe “Lectura del dd/mm/yyyy a lashh:mm:ss” en el fichero abierto y por último cierra el fichero.
29
4.3.2 loop()
Llegados a este punto, nos encontramos delante de la actividad principal deldispositivo, el corazón y el cerebro que dan vida al cuerpo, metáfora para recalcar laimportancia de las funciones siguientes.
Con un total de 14 funciones, se ha intentado separar ordenadamente las partes decódigo de cada componente que integran el dispositivo. Con ello conseguimos un códigolimpio y fácil de modificar en el caso de necesitar algún cambio de hardware o porposibles ampliaciones de él.
4.3.2.1 tratamientoMuestra()
En esta primera función invocada desde el loop principal, se encarga de invocarordenadamente al resto.
Primero invoca leeValorSensor(), almacenando en la variable global muestra laestructura lecturaSensor devuelta como resultado de la invocación. Luego analiza lamuestra comparándola con los valores originales del sensor a las muestras máxima ymínima. Si cumplen las condiciones se almacena la muestra actual en la muestramáxima o mínima según corresponda.
Seguidamente comprueba el estado de la variable HOLD, por si el usuario ha solicitadomantener la imagen del display congelada, en ese caso HOLD valdrá true se invoca lafunción impresionMuestra(), pasándole como parámetro la variable globalvalorMantener. Por contra HOLD valdrá false y se seguirá invocando la funciónimpresionMuestra() con parámetro la muestra tomada en esa iteración.
Por último comprueba si no se ha extraído la tarjeta microSD, mediante el estado de lavariable extraida, si su valor es false, la tarjeta permanece en funcionamiento, alactivarse la interrupción extraccionConSeguridad(), a petición del usuario; modificaráel valor de la variable a true. De esta manera se deja de invocar a la funciónguardarMuestra().
4.3.2.2 impresionMuestra()
La función impresionMuestra(lecturaSensor) esta declarada como void, recibe comoparámetro una struc del tipo lecturaSensor.
Primero comprueba el estado del dispositivo, si el usuario ha solicitado mostrar elmáximo y el mínimo, utilizando las funciones disponibles de la clase LiquidCrystal,librería la cual ha sido explicada en el capitulo 4.2.1; realiza una impresión por eldisplay LCD, de las variables muestraMax y muestraMin; mostrando sus polaridades,valor y la unidad de medición correspondiente con el valor mostrado.
30
Por contra, si no se solicitan el máximo y el mínimo; el dispositivo imprime las lecturastomadas una tras otra. De manera que en la fila 0 del display se imprime la polaridad, elvalor y la unidad del muestreo; y en la fila 1 del display se imprime el estado deldispositivo.
De manera que si HOLD es true se muestra una “H”, se muestra la unidad utilizada, elrango aplicado a la unidad, y por ultimo información correspondiente con la tarjeta SDinsertada, si hay tarjeta indica su tipo (SD1, SD2, SDH), y seguido el formato dearchivos de la tarjeta, si existe un problema con el formato de archivos imprime “FatE” o si no se puede escribir las muestras imprime “Error W”; por contra en caso de nohaber insertado tarjeta, imprime “Fallo SD”.
4.3.2.3 guardarMuestra()
Para guardar el valor de las distintas variables con información relevante, se invoca lafunción guardarMuestra(lecturaSensor) declarada void, necesita como parámetro unaestructura del tipo lecturaSensor almacenada en la variable ls..
Primero mediante la invocación de SD.open(nombreFichero, FILE_WRITE); carga elarchivo de registro en la variable archivoDatos y si se ha podido abrir, se procede aescribir una linea mediante la instrucción archivoDatos.println(); pasándole comoparámetro, una concatenación ordenada de la información recopilada; por otra parte sino se ha podido abrir se modifica el valor de la variable errorWrite a true.
En la concatenación primero se escribe la muestra actual, ls.polaridad, ls.valor yls.magnitud. Luego realiza el mismo proceso para la muestaMax y la muestraMin. Porúltimo imprime la hora de la variable muestra mediante ls.fechaYHora.
Luego de escribir la nueva linea en el archivo, cierre este mediantearchivoDatos.close(); y modifica el valor de la variable errorWrite a false.
4.3.2.4 leeValorSensor()
En esta función se realiza la lectura del sensor en un instante dado. Para ello nonecesita parámetros de entrada, pero si devolver la estructura lecturaSensor creada ensu invocación.
Para tomar la muestra, almacena en la variable valorOriginalNou del tipo int el valorde la entrada analógica mediante analogRead(SENSOR), además en la variablevalorNou del tipo double almacena el valor devuelto por la invocación a la funciónconvertirValor(valorOriginalNou).
También comprueba la polaridad de la señal captada mediante la comparaciónvalorOriginalNou >= bitsResolucion/2, donde bitsResolucion indica el numero totalde bits medido por el convertidor analógico-digital de la entrada analógica de Arduino
31
Due. Si el valor es mayor o igual se asigna “S” a la variable polNou del tipo String,sino asigna “N” a la misma variable.
Crea una struc del tipo lecturaSensor llamada nova a la cual asigna todos los camposobtenidos. El valorOriginalNou, el valorNou, el polNou, junto al estado de lasvariables globales RANGOACTUAL y TESLA. Es asignado espacio nulo (“”) en elString de la magnitud, y la hora y fecha del relog RTC mediante rtc.now().
Por último es invocada a la función magnitud(lecturaSensor) pasándole comoparámetro la estructura creada anteriormente nova, completando la informacióncorrespondiente .
4.3.2.5 convertirValor(int)
En esta función convertirValor(int) es invocada desde la función leeValorSensor()pasándole como parámetro de entrada el entero resultante a la lectura de la entradaanalógica A0.
La función convertirValor() se encarga de transformar el entero leído en la entradaanalógica, a su valor correspondiente en T o G. Para ello aplica la ecuación de la figura3.6.2. Esta ecuación esta explicada en el capitulo 3.2.1.
4.3.2.6 magnitud(lecturaSensor)
La función magnitud(), recibe como parámetro de entrada una estructura del tipolecturaSensor, y retorna otra estructura del mismo tipo.
La tarea de esta función es asignar a la estructura de entrada el String correspondiente asu magnitud de medida. Es decir asigna la representación correspondiente de la unidadde medida en el rango de magnitud en el que la lecturaSensor ha sido creada. Variaentre T, mT, uT, kG, G o mG.
Una vez asignado el String correspondiente, devuelve la estructura lecturaSensorcompleta a la función leeValorSensor().
4.3.2.7 Tratamiento interrupciones
En este apartado vamos a presentar las distintas funciones de gestión de interrupción.Una por cada pulsador de la botonera, un total de 6 útiles. Aunque existen 7 creadas, enArduino Due una de ellas, concretamente iluminacion() no es utilizada, porincompatibilidad de voltajes entre los pines digitales de la Arduino Due y el voltaje dealimentación de la iluminación del display LCD. Existe para poder usarla en la ArduinoMega con la incorporación de un pulsador más en la botonera.
32
Además hay que tener en cuenta que al tratarse de funciones de tratamiento deinterrupciones, se ha pretendido hacerlas lo más simples posibles para conseguir lamayor eficiencia posible.
Además en todas ellas se ha insertado unas lineas de código para controlartemporalmente la activación de las interrupciones, mediante una estructura de control ifdonde compara los tiempos obtenidos mediante millis(). De manera que si unainterrupción es solicitada otra vez antes de un 1,5 ms se considera que es a causa delefecto rebote o debounce.
4.3.2.7.1 mantener()
La interrupción declarada sobre el pulsador conectado al pin instanciado con la variableglobal HOLD, activa a la función mantener(), encargada de gestionar a la variableHOLDS del tipo boolean.
En la variable HOLDS queda reflejada la interacción del usuario solicitando mantenercongelada la muestra en ese instante dado. Todo el proceso de detección de la variableHOLDS se lleva a cabo en las función tratarMuestra(). La gestión de la interrupciónconsiste solamente en modificar el valor de la variable HOLDS.
Dicha variable cuando su valor es false, el usuario quiere ver por el display elseguimiento del sensor, además por tiene este valor al iniciarse el dispositivo. Por elcontrario al solicitar congelar la imagen su valor es modificado a true.
4.3.2.7.2 unidades()
La función unidades() es invocada con la activación de la interrupción asociada al pininstanciado con la variable global UNITS. Esta función modifica el valor de la variableglobal TESLA, en la cual queda reflejado la solicitud del usuario a representar lamedida del campo magnético en Tesla o en Gauss.
Cuando la variable TESLA esta con valor true significa que el usuario quiererepresentar la medición en Tesla, además al iniciarse el dispositivo se inicializa a truepor defecto. Mientras que si la variable vale false el usuario quiere representar lainformación en Gauss.
La variable TESLA es usada en las funciones leeValorSensor(), convertirValor() eimpresionMuestra().
4.3.2.7.3 iluminacion()
Esta función tiene asociada la interrupción del pulsador conectado al pin instanciadocon la variable BOTONLLUM, al activarse esta interrupción la función iluminacion()modifica el valor de la variable global apagada.
33
El valor por defecto al iniciarse el dispositivo es true, esto hace que la funcióniluminacion() ejecute la instrucción digitalWrite(LLUM, HIGH), haciendo que el pin14 del display LCD reciba 5V y encienda la iluminación de la pantalla. Mientras que almodificar su valor a false, ejecuta digitalWrite(LLUM, LOW), apagando lailuminación.
4.3.2.7.4 rangos()
La interrupción activada por el pulsador conectado al pin instanciado por la variableRANGO, invoca la función rangos(), encargada de la modificación de la variableglobal RANGOACTUAL del tipo int, instanciada mediante constrain(RANGOACTUAL, 0, 2) de manera que solo puede tener tres valores el 0, 1 y 2.
En la función rangos() se incrementa su valor, teniendo en cuenta que al llegar a 2modificamos el valor a 0.
La variable RANGOACTUAL modifica el comportamiento de las funcionesimpresionMuestra(), leeValorSensor() y convertirValor().
4.3.2.7.5 maximoMinimo()
Otra función encargada de la gestión de interrupciones, es la funciónmaximoMinimo(), esta esta asociada a la interrupción activada por el pulsadorconectado al pin instanciado por la variable global MAXMIN.
La función maximoMinimo(), al ser invocada modifica la variable globalMAXIMOMINIMO del tipo boolean. Esta variable por defecto su valor es false, deesta manera en la función impresionMuestra() imprima el muestreo del sensor. Por elcontrario, cuando su valor es true la función impresionMuestra() imprime el máximoy el mínimos almacenados hasta el momento.
4.3.2.7.6 extraerConSeguridad()
La interrupción para la extracción segura de la tarjeta SD, se gestiona mediante larutina extraerConSeguridad() invocada por el pulsador conectado al pin instanciadocon la variable global EXTRACT del tipo boolean.
Dicha función examina la variable global extraida del tipo boolean, si su valor es truemodifica a la variable extraida a false y además a otra variable boolean llamada iniSd atrue. Por otra parte al valer extraida false, esta función modifica estas dos mismasvariables a su opuesto, es decir, extraida queda a true y iniSd queda a false.
La variable extraida afecta a la funciones impresionMuestra() y tratarMuestra().Mientras que la variable iniSd afecta a las funciones impresionMuestra() yinicializaSd().
34
4.3.2.7.7 borrado()
Por finalizar con las rutinas de gestión de interrupciones, tenemos la funciónborrado(), ella es invocada mediante la instanciación del pin BORRADO, con laintención de gestionar la renovación del archivo de registro de datos.
Para ello invoca la función borradoInformacion(). Además controla temporalmentelas instancias a la gestión de interrupciones borrado(), eliminando llamadasinvoluntarias producidas por el efecto rebote del circuito eléctrico de la interfaz deusuario.
4.3.2.7.8 borradoInformacion()
La función borradoInformacion() es invocada por la rutina de interrupción borrado(). Seocupa de eliminar el archivo de registro de datos de la tarjeta SD, con nombre el Stringalmacenado en la variable nombreFichero. Posteriormente invoca a la funcióncreaFichero().
4.4 Montaje del dispositivo en su caja
Durante este apartado, se va exponer paso a paso el montaje de los componentes en lacaja para tener el dispositivo acabado.
4.4.1 Preparativos
Para el montaje necesitamos, deformar los cilindros de plástico de manera que dejemosel orificio al tamaño de nuestros tornillos reciclados.
35
Figura 4.2: Reciclado y deformación de cilindros de plástico para porta-tornillos
Luego atornillar los porta-tornillos que acabamos de modificar a los orificioscorrespondientes de los componentes y soldarlas con termo-silicona o con otroadhesivo a la caja en la ubicación decidida para ese componente.
Una vez fijadas las bases para el atornillado se puede montar el circuito de la figura3.3, y verificar la buena colación de los componentes y el cableado de conexión. Unavez comprobado podemos desconectar el cableado y desatornillar los componentes delas fijaciones. Previamente marcaremos las zonas a perforar para dejar hueco paraconectores, la pantalla y los botones.
4.4.1.1 Realizar las perforaciones
Para perforar las zonas de los conectores, botones y pantalla; utilizaremos un soldadorde estaño o un pirograbador.
Quemaremos las marcas realizadas previamente y comprobaremos que acoplancorrectamente. Seguidamente limamos y pulimos los contornos de las perforaciones.
4.4.1.2 Soldado de la botonera y de la ampliación de pines de alimentación
Siguiendo el diseño realizado de interconexión de la botonera, se realizara a laimplementación sobre una placa de cobre perforada siguiendo una matriz, colocaciónde los botones, resistencias y el condensador para eliminar el efecto rebote.
Una vez soldado con estaño los componentes y los cables de conexionado con laArduino Due se realiza un testeo de la tensión del circuito, comprobando su correctaimplementación.
36
Figura 4.3: Componentes con tornillos y porta tornillos
Además en una porción de una PCD se conectan conectores hembra para ampliar lospines de alimentación de 3.3V y GND. Y en el se coloca el potenciómetro que necesitael display LCD.
Y el sensor Hall A1318, con tres cables de conexionado, GND, VCC, DATA.
4.4.2 Colocación y conexionado de los componentes
Una vez preparados podemos colocar los componentes en su posición y procedemos aimplementar la interconexión diseñada previamente. Para ello nos basamos en la figura3.9.
4.4.3 Cierre y comprobación del acabado
Teniendo ya todo bien conectado procedemos a cerrar la caja y comprobar si todoencaja bien. En caso de que no encaje bien, tendremos que volver a colocar loscomponentes como se comenta en el capitulo 4.4.1, en ocasiones es recomendable eluso de pines macho curvado para el uso en lugares con poco espacio.
Cuando este todo bien colocado y ninguna conexión se fuerce, el dispositivo estapreparado para probarlo.
37
Figura 4.4: Caja acabada y circuito de conexionado montado
4.4.4 Cargar el código fuente
Por último, subimos el código fuente a través de la interfaz de Arduino. Para su ejecución y puesta a punto.
38
Figura 4.5: Teslametro con Arduino y reciclaje de desechos plásticos
Capitulo 5 : Comprobación
Durante este capitulo vamos a exponer los pasos seguidos para comprobar el correctofuncionamiento del dispositivo.
5.1 Pruebas caja blanca y caja negra
Una vez el dispositivo esta montado y el código finalizado, procedemos a realizar unaserie de pruebas para comprobar su correcto flujo de datos, y la cohesión entre lasdistintas funciones.
Para ello primero realizamos la prueba de caja blanca que consiste en un seguimientoen la ejecución del programa. Mediante la impresión de comentarios al comenzar unafunción, durante su procedimiento y al salir de la función. De esta manera podemosobservar si el dispositivo ejecuta todo el código. Además se forzara a recorrer todas lafunciones a través de la interacción con la interfaz de usuario. Como resultadoobtendremos un registro detallado de las distintas rutas que sigue la ejecución delcódigo fuente.
Posteriormente se analiza dicho registro y se comprueba que no queda bloqueado enninguna función y que realiza correctamente su funcionamiento tal como quedareflejado en los diagramas de flujo diseñados.
Por último se realiza la prueba de caja negra, de manera que se analiza elcomportamiento del dispositivo a partir de las entradas proporcionadas a la interfaz deusuario y el resultado del comportamiento del dispositivo. El objetivo es comprobarque el dispositivo hace el comportamiento esperado.
5.2 Comprobación con otro Teslámetro
Seguidamente a la comprobación del correcto funcionamiento, es necesario contrastarla función de adaptación de la señal obtenida por el sensor. Para ello compararemos lasmedidas obtenidas con nuestro dispositivo con las muestras obtenidas por unTeslámetro comercial.
Haciendo uso del Teslametro PHYWE del laboratorio Nikola Tesla de la ETSINF,hemos contrastado el magnetómetro construido con Arduino. Tras unos cuantos errores,conseguimos el modelo correcto. Para contrastar que las medidas son correctas,medimos el campo magnético de una bobina la cual generaba hasta 25mT en suinterior, nosotros pudimos medir el exterior, debido a la ausencia de sonda externa. Yademás medimos el campo magnético de un imán.
39
40
Figura 5.1: Gráfica comparativa teslametros midiendo una bobina
1 2 3 4 5 6 7 8 9 10 11 12 13 14
-5
-4
-3
-2
-1
0
1
2
3
4
5
Comparativa Teslametros
Medida de la parte externa de una bobina
teslametro_arduino phywe_teslametro
nº muestras
B (
mT
)
Figura 5.2: Gráfica comparativa teslametros midiendo un imán.
1 2 3 4 5 6 7 8 9 10-30,00
-25,00
-20,00
-15,00
-10,00
-05,00
00,00
05,00
10,00
15,00
20,00
25,00
30,00
Comparativa Teslametros
Medida de un imán
teslametro_arduino phywe_teslametronº muestras
B (mT)
Capitulo 6 : Presupuesto
En este capitulo se desglosa la organización temporal seguida para el desarrollo de esteproyecto, como además los presupuesto del hardware usados y del softwaredesarrollado.
6.1 Diagrama de Gannt
Figura 6.1: Planificación temporal para la realización del trabajo
En la figura 6.1 se puede observar la planificación temporal realizada para laelaboración del proyecto.
41
6.2 Presupuesto hardware
Los componentes del dispositivo se han comprado en la tienda on-line y en una tienda deelectrónica convencional.
Componentes Precio Unidades Precio total unidades
Arduino Due 33,06 € 1 33,06 €
Display LCD 7,87 € 1 7,87 €
Adalogger FeattherWing 9,22 € 1 9,22 €
Sensor Hall A1318 1,413 € 1 1,41 €
PCB matriz 70x70mm 4,73 € 1 4,73 €
Pulsadores 0,2664 € 6 1,5984 €
Resistencia fija 10kΩ 0,816 € 6 4,90 €
Potenciómetro 50kΩ 0,89 € 1 0,89 €
Cables de conexionado 0,08 € 40 3 €
Total sin
IVA
66,7674 €
IVA 21% 14,00 €
Total 80,68 €
Tabla 6.2: Presupuesto hardware de cada dispositivo.
42
6.3 Presupuesto software
En este último apartado del capitulo 6, vamos a presentar un presupuesto al trabajorealizado. Según el sueldo marcado por el XVI CONVENIO COLECTIVOESTATAL DE EMPRESAS DE CONSULTORÍA Y ESTUDIOS DEMERCADOS Y DE LA OPINIÓN PÚBLICA, y según el tiempo planificadoen el capitulo 6.1, obtenemos:
Trabajo Horas Precio hora Precio del trabajo
Análisis 40 8 € 320 €
Diseño 40 8 € 320 €
Implementación 80 8 € 640 €
Comprobación 20 6 € 120 €
Total sin IVA 1400 €
IVA 21% 294 €
Total 1694 €
Tabla 6.3: Presupuesto del trabajo por desarrollo del dispositivo.
43
6.4 Comparación con un Teslametro comercial
Modelo Precio Rango Sensibilidad Portabilidad
Teslametro Arduino
80.68 € [-126.923 mT, 126.923 mT] 0,247 mT Transformador 220 V AC a 5-7V DC o batería portátil USB
BST600 Gaussmeter
305,24 € DC*1: 0.00~200.00mT DC*10: 0.0~2000.0mT AC*1: 0.00~200.00mTAC*10: 0.0~2000.0mT
DC*1 : 0.01mTDC*10 0.1mTAC*1 : 0.01mTAC*10 0.1mT
Transformador 220V AC a 9V DC o batería de 9V DC
Phywe Teslametrodigital
2000 € DC*1: 0.00~20.00mT DC*10: 0.00~200.00mT DC*100: 0.0~2000.0mT AC*1: 0.00~20.00mT AC*10: 0.00~200.00mTAC*100: 0.0~2000.0mT
DC*1: 0.01mT DC*1: 0.1mTDC*10: 1mTAC*1: 0.01mTAC*10: 0.1mT AC*100: 1mT
Conexión a 220V AC
Tabla 6.4: Tabla comparativa Teslametros
44
Capitulo 7 : Resultados y conclusionesEn este ultimo capitulo, vamos a exponer las mayores dificultades encontradas duranteel desarrollo del proyecto, las experiencias del trabajo realizado y posibles ampliacionesen un futuro.
7.1 Problemas y contratiempos
En la elaboración del Magnetómetro, se han planteado algunas problemáticas,relacionadas con el software desarrollado y por el hardware escogido.
• La problemática más importante ha sido escoger la caja del dispositivo. La decisiónde la auto-construcción de ella, ha sido por motivos ideológicos, teniendo en cuentala cantidad de residuos generados y desechados, por lo que me veo obligado acontribuir en la desaparición y gestión de los residuos. Por otra parte es complicadoescoger un tupper-ware de unas dimensiones adecuadas a todo el cableado ycomponentes del dispositivo. Al igual que las perforaciones de los conectores,botones y pantalla; donde realizamos unas cuantas pruebas antes de realizar lasperforaciones finales, pero aun así los cortes no son perfectos y en ellos se ve laartesanía manual de su elaboración.
• Otra problemática software, es la forma de detectar la activación de los pulsadores.En un primer instante se planteo por comprobación de estado, resulto ser un fracaso;ya que muchas pulsaciones no eran detectadas, y ralentizaba la interacción delusuario con el dispositivo. Por tanto nos planteamos la detección por interrupciones,al principio de la implementación, no se había tenido en cuenta el efecto rebote odebounce. De esta manera el dispositivo se saturaba con interrupciones y dejaba defuncionar. Tras una pequeña inspección del problema se observo que requería deprotección contra dicho efecto y se dispuso de un condensador de 6 uF en el circuitofísico de la botonera, además de la implementación software explicada al principiodel capitulo 4.3.2.7.
• Y la última complicación sufrida, recae en el proceso de adaptación de la señalcaptada por el sensor a la transformación del valor del campo en T o G. Habiendoestado más tiempo del planificado planteando posibilidades para la implementación,de las cuales todas eran planteamientos erróneos. Con unas cuantas semanas deplanteamientos teóricos y probándolos sobre el dispositivo, obtuvimos el modelocorrecto explicado en el capitulo 3.1.6.
45
7.2 Experiencias y valoraciones del trabajo realizado
En el transcurso del trabajo, nos hemos aproximado a los Magnetómetros y a lafabricación de dispositivos de laboratorio, con un precio muy reducido.
Hemos sido participes de la formación del dispositivo, desde la observación y análisisde los modelos comerciales, hasta su diseño e implementación, y como no de sucomprobación y puesta a punto. Con ello hemos desarrollado nuestras capacidades deelaborar dispositivos, ya sea comprendiendo y desarrollando el software, como ladetección y selección del hardware y puesto en practica de los métodos de pruebas deverificación del buen funcionamiento del dispositivo.
Con ello hemos practicado mucho del conocimiento adquirido durante el grado deinformática. Y puesto en practica con un ejemplo real, el cual se va a replicar y utilizaren los laboratorios de física aporta una gran relevancia a la experiencia obtenida.
7.3 Ampliaciones
Para finalizar, vamos a exponer brevemente alguna de las posibles ampliaciones que dapie este proyecto. Desde la ampliación del Magnetómetro resultante, como lamodificación del software para hacer que el dispositivo cumpla otro cometido.
• Ampliación del Magnetómetro: modificando el sensor Hall por uno del tipovectorial, ampliaríamos nuestras mediciones del campo magnético en los tresvectores espaciales (X, Y, Z). Por otra parte, se puede modificar el firmware delpuerto USB-Nativo para que se conecte a un PC y desde él puedas acceder a losdatos almacenados en la tarjeta SD. Otra posible ampliación, seria una conexiónbluetooh, para transmisión de datos en tiempo real de forma inalámbrica, o paraacceder a los datos almacenados en la tarjeta SD. Y por supuesto se pueden añadircanales de medición adicionales, solamente con añadirle sensores; o se podríaextraer el sensor a una sonda.
• Ampliación software: se puede ampliar el código fuente, introduciendo nuevosfuncionamientos al dispositivo, como podría ser un generador de señales, unosciloscopio, u otros dispositivos de laboratorio. De esta manera conseguiríamosobtener en un único dispositivo varios aparatos necesarios para desarrollo dedispositivos electrónicos. Además, deja la posibilidad de rehacer el código en C++,creando una librería para la IDE de Arduino, o de escribir el funcionamiento delMagnetómetro a bajo nivel, realizando todo el proceso que en este proyecto se haomitido utilizando las librerías disponibles en Arduino.
De esta manera se podría conseguir un dispositivo con una programación a alto nivelimplementada en el IDE de Arduino, fácil de explicar y utilizar como ejemplo enasignaturas como DIP. Se tendría también el código escrito en C++ formando unalibrería, con la que se podría emplear en asignaturas como MEC; y por ultimo el código
46
a bajo nivel útil para asignaturas como AIC, AAV, DSD, IIN. Pudiendo tener un ejemplocomún entre por ejemplo DIP, MEC y IIN las cuales están relacionadas pero sin másconexión que las temáticas tratadas, es decir, carecen de ejemplos comunes que haganfácil visualizar la relación entre los distintos puntos de vista impartidos en cada una delas ellas.
7.4 Conclusiones
1. Es posible construir un Teslametro de un coste de construcción de 80 €.
2. Es posibles reciclar materiales para la construcción de la caja del Teslametro.
3. Es posible desarrollar un Teslametro con la plataforma Arduino.
4. Es posible conseguir una medidas comparables a las de un Teslametro
comercial.
47
Bibliografía
[1] Adafruit. RTClib. Consultado el 05/02/2017
https://github.com/adafruit/RTClib/blob/master/RTClib.h
[2] Arduino. AnalogReadResolution. Consultado el 02/02/2017
https://www.arduino.cc/en/Reference/AnalogReadResolution
[3] Arduino. Arduino Due. Consultado el 01/02/2017
https://www.arduino.cc/en/Main/ArduinoBoardDue
[4] Arduino. Forum fat16lib. Consultado el 01/02/2017
https://forum.arduino.cc/index.php?topic=65558.0
[5] Arduino. HallEfect. Consultado el 03/02/2017
http://playground.arduino.cc/Code/HallEffect
[6] Arduino. LiquidCrystal. Consultado el 04/02/2017
https://www.arduino.cc/en/Reference/LiquidCrystal
[7] Arduino. Productos de Arduino. Consultado el 12/01/2017
https://www.arduino.cc/en/Main/Products
[8] Arduino. SD. Consultado el 05/02/2017
https://www.arduino.cc/en/Reference/SD
[9] Arduino. SPI. Consultado el 06/02/2017
https://www.arduino.cc/en/reference/SPI
[10] Arduino. Wire. Consultado el 07/02/2017
https://www.arduino.cc/en/Reference/Wire
48
[11] Boletin oficial del Estado. XVI CONVENIO COLECTIVO
ESTATAL DE EMPRESAS DE CONSULTORÍA Y ESTUDIOS
DE MERCADOS Y DE LA OPINIÓN PÚBLICA Consultado el
13/02/2017
https://www.boe.es/boe/dias/2009/04/04/pdfs/BOE-A-2009-5688.pdf
[12] BST600. AlliExpress. Consultado el 08/02/2017
https://es.aliexpress.com/store/product/BST600-Gaussmeter-Teslameter-AC-
DC-magnetic-field-gauss-meter-Tesla-BST-600-0-200mT-
2000mT/1422139_32622700574.html
[13] Datasheet A1318. AllegroMicro. Consultado el 08/02/2017
https://www.google.es/url?
sa=t&rct=j&q=&esrc=s&source=web&cd=8&ved=0ahUKEwiJl-6z-
8bSAhWpBcAKHUVtB5MQFghEMAc&url=http%3A%2F
%2Fwww.allegromicro.com%2F~%2Fmedia%2FFiles%2FDatasheets
%2FA1318-A1319-
Datasheet.pdf&authuser=1&usg=AFQjCNHQKewhUh9X4PWVjf1DSYEHH
xV0Sw&sig2=OiXHcD2P8VVRrHC8rNQLPA&cad=rja
[14] Efecto Hall. Edu GVA. Consultado el 12/01/2017
http://intercentres.edu.gva.es/iesleonardodavinci/Fisica/Electromagnetismo/El
ectromagnetismo07b.htm
[15] Real Academia de la Legua Española. Definición de
magnetómetro. Consultado el 15/01/2017
http://dle.rae.es/?id=NtmaBLd
49
[16] RSComponents. Productos. Consultado el 13/01/2017
http://es.rs-online.com/web/
[17] Magnetómetro. 5HertzElectronica. Consultado el 12/01/2017
http://5hertz.com/tutoriales/?p=623#mgn2.
[18] Wikipedia. Magnetómetro. Consultado el 12/01/2017
https://es.wikipedia.org /wiki/Magnet%C3%B3metro
50
Apéndice Código fuente
0123456789
10111213141516171819202122232425262728293031323334353637383940
#include <LiquidCrystal.h>#include <SPI.h>#include <SD.h>#include <Wire.h>#include "RTClib.h"
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Definición de variables ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////acceso rápido al pin dedicado a botones o pines de actuadores o sensores//botones llamada a ISR#define HOLD 20#define RANGO 3#define UNITS 18#define BOTONLLUM 22#define BORRADOR 19#define MAXMIN 21#define EXTRACT 2//sensor#define SENSOR A0//salida iluminacion pantalla//#define LLUM 10//entrada cs modulo sd#define CS 53
//el reloj rtc de adaloger usa los puerto SDA1 y SCL1 en Arduino Due. En Arduino Mega usan//SDA y SCL que son el pin 20 y 21, tenemos un conflicto de pines para Arduino Mega, con//Hold y MaxMix
RTC_Millis rtc;
//variables para medición tiempounsigned long currentMillis, previousMillis = 0;const long tiempo = 500, tiempoDisplay = 1000;
//para anular el debounce de la botoneraconst int timeThreshold = 150;int counterHold, counterLuz, counterRango, counterUnits, counterMaxMin, counterExtract= 0; int counterBorrado = 0;unsigned long currentHold, currentLuz, currentRango, currentUnits, currentMaxMin, currentExtract, currentBorrado = 0;
51
41424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586
//variables volátiles para la gestión de interrupciones volatile boolean HOLDS = false; //botón holdvolatile boolean TESLA = true; //botón unitsvolatile boolean MAXIMOMINIMO = false; //botón MAXMINvolatile boolean extraida = false; //botón MAXMIN
//variables sdboolean iniSd = false;boolean errorWrite = false;unsigned long numMuestra = 0;String nombreFichero = "datos.txt";
//variables para aplicar a la función hold y maxMinstruct lecturaSensor { int valorOriginal; double valor; String polaridad; int rango; boolean unidad; String magnitud; DateTime fechadora; };
//estructura de datos para almacenar la información acerca de una muestra.DateTime dt0 (0, 0, 0, 0, 0, 0);lecturaSensor muestra, valorMantener, muestraMax = {1000, 0, "", 0, true, "", dt0};lecturaSensor muestraMin = {0, 0, "", 0, true, "", dt0};
//variables de rangos; double rangoT[3]= {0.001, 1.0, 1000.0};double rangoG[3]= {0.001, 1, 1000};int RANGOACTUAL = constrain (RANGO,ACTUAL, 0, 2);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////Variables y métodos Modulo SD/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////Sd2Card card;SdVolume volume;
File archivoDatos;
void inicializaSD(){//Serial.println("Inicialización del modulo SD:");//intentamos inicializar la tarjeta sd. si no inicializa lo marcamos con la variable iniSd a false//para reintentarlo mas tarde
52
87888990919293949596979899
100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132
if (!SD.begin(CS)) { iniSd = false; }else{ iniSd = true; }//habilita la tarjeta de forma que se puede leer su configuración if (!card.init(SPI_HALF_SPEED, CS)) { //Serial.println("Inicializada la tarjeta"); } //comprueba si existe el archivo de texto, sino esta lo crea y lo cierra. if(!SD.exists(nombreFichero)){ creaFichero(); //Serial.println("Inicializado el fichero"); }//Serial.println("Completada");
}
//si abre bien el archivo imprime la lectura y el estado de la memoria, sino modifica la variable//errorWrite para mostrar un error en display lcdvoid guardarMuestra(lecturaSensor ls){ //Serial.println("Proceso de guardado:"); archivoDatos = SD.open(nombreFichero, FILE_WRITE); //Serial.println(" Se ha abierto el fichero: "+nombreFichero); if (archivoDatos){ //Guarda numMuestra ls.polaridad ls.valor magnitud Maximo: muestraMax.polaridad muestraMax.valor magnitud Mínimo: muestraMin.polaridad muestraMin.valor magnitud //archivoDatos.println("N 30 mG; Maximo; Mínimo; Hora ... "); archivoDatos.println(ls.polaridad+" "+ls.valor+" "+ls.magnitud+ “; ”+ muestraMax.polaridad+" ” +muestraMax.valor+" "+muestraMax.magnitud+ “; ”+ muestraMin.polaridad+" "+muestraMin.valor+" "+muestraMin.magnitud+ “; ”+ ls.fechaYHora.day()+"/"+ls.fechaYHora.month()+"/"+ls.fechaYHora.year()+ “; ”+ ls.fechaYHora.hour()+":"+ls.fechaYHora.minute()+":"+ls.fechaYHora.second()); archivoDatos.close();
errorWrite = false; //Serial.println("Se ha guardado la muestra: "+numMuestra); }else{ //Error al abrir el archivo errorWrite = true; //Serial.println("Error al guardar la muestra: "+numMuestra); } }
void borradoInformacion(){ archivoDatos = SD.open(nombreFichero, FILE_WRITE); SD.remove(nombreFichero); //Serial.println("Se ha borrado el archivo: "+nombreFichero);
53
133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178
creaFichero();}void creaFichero(){ DateTime ahora = rtc.now(); archivoDatos = SD.open(nombreFichero, FILE_WRITE); archivoDatos.print("Lectura del "+ahora.day()); archivoDatos.print(+"/"+ahora.month()); archivoDatos.print(+"/"+ahora.year()); archivoDatos.print(+" a las "+ahora.hour()); archivoDatos.print(+":"+ahora.minute()); archivoDatos.print(+":"+ahora.second()); archivoDatos.println(); archivoDatos.close(); //Serial.println("Se ha creado el archivo: "+nombreFichero);}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// variables de pantalla ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//definición de la pantalla lcd con parámetros RS pin 8, E pin 9, d4-7 pines 4-7LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
//variable control iluminacionboolean apagada = true;
//Inicializa la pantalla lcd y muestra el mensaje inicialvoid inicialicizaPantalla(){ //Serial.println("Inicialización del display:"); lcd.begin(16, 2); // Inicializar el LCD lcd.clear(); //limpia la pantalla //Serial.println("Completada");}
void impresionMuestra(lecturaSensor ls){
if(!MAXIMOMINIMO){ //Serial.println("Se imprime en el display la muestra actual:"); lcd.setCursor(1,0); //muestra la polaridad de la señal magnética captada. lcd.print(ls.polaridad); //imprime en la parte superior de la pantalla el valor obtenido junto con la magnitud en
//la que esta expresado
if(ls.valor<0){ lcd.setCursor(3,0);
54
179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224
lcd.print(ls.valor); lcd.print(ls.magnitud); }else{ lcd.setCursor(4,0); lcd.print(ls.valor); lcd.print(ls.magnitud); } //Serial.println(ls.polaridad+" "+ls.valor+" "+ls.magnitud); lcd.setCursor(1,1); if(HOLDS) lcd.print("H"); lcd.setCursor(3,1); if(TESLA) lcd.print("T"); else lcd.print("G"); lcd.setCursor(5,1); lcd.print(RANGOACTUAL); //Serial.print("Mantener: "); //Serial.print(HOLDS); //Serial.print(", Unidades(Tesla = true, Gauss = false): "); //Serial.print(TESLA); //Serial.print(", Rango: "); //Serial.print(RANGOACTUAL); //Serial.print(", "); //muestra información de la sd lcd.setCursor(7,1); if(!extraida){ if(!iniSd){ lcd.print("Fallo SD"); //Serial.print("Modulo SD: FalloSD ") }else{ switch (card.type()) { case SD_CARD_TYPE_SD1: lcd.print("SD1 "); //Serial.print("Modulo SD: SD1 "); break; case SD_CARD_TYPE_SD2: lcd.print("SD2 "); //Serial.print("Modulo SD: SD2 "); break; case SD_CARD_TYPE_SDHC: lcd.print("SDH "); //Serial.print("Modulo SD: SDH "); break; default: lcd.print("NN "); //Serial.print("Modulo SD: ERROR DISK "); } if(!errorWrite){
55
225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270
lcd.print("FAT"); //Serial.print("FAT "); //indica el tipo de formato de fat que tiene la sd if (!volume.init(card)){ lcd.print(" ERROR"); //Serial.print("ERROR "); SD.begin(CS); }else lcd.print(volume.fatType(),DEC); //Serial.print(volume.fatType(), DEC); }else{ lcd.print("ERR W"); //Serial.print("Error de escritura"); } } }else{ lcd.print("Extract"); //Serial.println("Tarjeta extraida"); } }else{ //Serial.println("Se imprime al display las muestras máxima y mínima: "); lcd.setCursor(2,0); //muestra la polaridad de la máxima señal magnética captada. lcd.print(muestraMax.polaridad); //imprime en la parte superior de la pantalla el valor obtenido junto con la magnitud en la //que esta expresado lcd.setCursor(4,0); lcd.print(muestraMax.valor); lcd.print(muestraMax.magnitud); //Serial.println("Maximo: "+muestraMax.polaridad+" "+muestraMax.valor+" "+muestraMax.magnitud); lcd.setCursor(2,1); //muestra la polaridad de la señal magnética captada. lcd.print(muestraMin.polaridad);
//imprime en la parte superior de la pantalla el valor obtenido junto con la magnitud en la //que esta expresado lcd.setCursor(4,1); lcd.print(muestraMin.valor); lcd.print(muestraMin.magnitud); //Serial.println("Mínimo: "+muestraMin.polaridad+" "+muestraMin.valor+" "+muestraMin.magnitud); }}////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
56
271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316
//////////////////////////////////////////////// variables de sensor hall /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//variables para el tratamiento del valor del sensor hall.
//1.3mV = 1Gaussconst double VMax = 3300.0;const double bitsResolucion = 1024;const double VSensor = 1.3;
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// métodos sensor hall /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
lecturaSensor leeValorSensor(){ //Serial.println("Lectura del Sensor"); int valorOriginalNou = analogRead(SENSOR)-18; double valorNou = convertirValor(valorOriginalNou); String polNou = ""; if(valorOriginalNou >= bitsResolucion/2) polNou = "S"; else polNou = "N";
lecturaSensor nova ={valorOriginalNou, valorNou , polNou, RANGOACTUAL, TESLA, "", rtc.now()};
nova = magnitud(nova); numMuestra++; return nova;}
//* Método de transformación del valor recogido por el sensor. Dependiendo de la unidad seleccionada, se transformara a Teslas o a Gauss, viene dado por el valor de la variable boleana Tesla, si esta a true, esta seleccionada la magnitud estándar del sistema internacional Tesla, mientras que si esta en false se mostrara en Gauss. Este método retorna un double, con el valor transformado. En definitiva el dispositivo puede medir entre [-128 mT. 128 mT]*/ double convertirValor(int val){//Serial.println("Se procesa el valor captado aplicándole la ecuación de adaptacion: (val*((VMax/(VSensor*10))/(bitsResolucion)))-((VMax/(VSensor*10))/(2))"); double res = (val*((VMax/(VSensor*10))/(bitsResolucion)))-((VMax/(VSensor*10))/(2)); //esto calcula el valor en mT if(TESLA){//en tesla res = res * rangoT[RANGOACTUAL]; }else{//en gauss
57
317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362
res = res * rangoG[RANGOACTUAL]*10000; } //Serial.println("Finalizada el calculo de la ecuación de adaptacion de la señal."); return -res;}
lecturaSensor magnitud(lecturaSensor ls){ if(ls.unidad){ if(ls.rango==0) ls.magnitud = " T"; else if(ls.rango==1) ls.magnitud = " mT"; else if(ls.rango==2){ ls.magnitud = " uT"; } }else{ if(ls.rango==0) ls.magnitud = " kG"; else if(ls.rango==1) ls.magnitud = " G"; else if(ls.rango==2){ ls.magnitud = " mG"; } } return ls;}//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Tratamiento de interrupciones //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//interrupción de mantenervoid mantener(){ //Serial.println("Invocación de la rutina mantener()");
currentHold = millis();if (currentHold > counterHold + timeThreshold) {
HOLDS = !HOLDS;counterHold = millis();
} //Serial.println("Finalizada la rutina mantener()");}//interrupción de unidadesvoid unidades() {
currentUnits = millis();if (currentUnits > counterUnits + timeThreshold){
TESLA = !TESLA;counterUnits = millis();
58
363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408
}}//interrupción de iluminacion/*void iluminacion(){
currentLuz = millis();if (currentLuz > counterLuz + timeThreshold) {
if (apagada) {//enchufar la luzdigitalWrite(LLUM, HIGH);
}else {
//apagar la luzdigitalWrite(LLUM, LOW);
}apagada = !apagada;counterLuz = millis();
}}*///Incrementa el RANGOACTUAL de forma cíclicavoid rangos(){ //Serial.println("Invocación de la rutina rangos()");
currentRango = millis();if (currentRango > counterRango + timeThreshold) {
if (RANGOACTUAL == 2)RANGOACTUAL = 0;
elseRANGOACTUAL++;
counterRango = millis();}
//Serial.println("Finalizada la rutina rangos()"); }//interrupción de MAXIMOMINIMOvoid maximoMinimo(){ //Serial.println("Invocación de la rutina maximoMinimo()");
currentMaxMin = millis();if (currentMaxMin > counterMaxMin + timeThreshold) {
MAXIMOMINIMO = !MAXIMOMINIMO;counterMaxMin = millis();
} //Serial.println("Finalizada la rutina maximoMinimo");}//interrupción de EXTRACTvoid extraerConSeguridad(){ //Serial.println("Invocación de la rutina extraerConSeguridad()");
currentExtract = millis();if (currentExtract > counterExtract + timeThreshold) {
59
409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454
if (extraida) {iniSd = true;extraida = false;
}else {
extraida = true; iniSd = false;
}counterExtract = millis();
} //Serial.println("Finalizada la rutina extraerConSeguridad()");}//método de borrado del archivo de datos. Al ser invocado se eliminara el archivo de datos dejándolo otra vez vacíovoid borrado(){ //Serial.println("Invocación de la rutina borrado()"); currentBorrado = millis(); if (currentBorrado > counterBorrado + timeThreshold) { borradoInformacion(); counterBorrado = millis(); } //Serial.println("Finalizada la rutina borrado()"); }///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////Tratamiento de la lectura de la muestra////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/ * Este método toma una lectura del sensor actualizando la struct muestra.* Luego dependiendo de las interrupciones HOLD, UNIT, MAXMIN modifican el comportamiento * * -HOLD: dependiendo de una variable boolean utiliza la struct muestra o valorMantener * -UNIT: varia entre Tesla o Gauss, las unidades de medida de campo magnético. * -RANGO: varia la variable rangoActual entre 0, 1, 2. donde además varia el valor en la * conversión del valor leído del sensor. * /void tratarMuestra(){ //Serial.println("Inicio de la gestión de la muestra: "+numMuestra); //tomamos una muestra muestra = leeValorSensor(); //tratamiento de los máximos y mínimos, queda definir la diferencia entre los rangos if(muestra.valorOriginal>muestraMax.valorOriginal){ muestraMax = muestra; //Serial.println("La muestra es maximo"); } if(muestra.valorOriginal<muestraMin.valorOriginal){
60
455456
457
458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498
muestraMin = muestra; //Serial.println("La muestra es mínimo"); } //tratamiento de hold if(HOLDS){ impresionMuestra(valorMantener); //Serial.println("Se congela la muestra a imprimir"); }else{ impresionMuestra(muestra); valorMantener = muestra; //Serial.println("Se imprime la muestra actual"); } if(!extraida){ //Serial.println("Tarjeta no extraida, se procede a guardar la muestra: "+numMuestra); guardarMuestra(muestra); }}/* Primero que todo se inicializan los pines para los botones HOLD, UNITS, RANGO, MAXMIN,LLUM, CS, BOTONLLUM luego se inicializan las interrupciones asociadas a cada botón con su respectivo código detratamiento de interrupciones Posteriormente se calibra el sensor, y se inicializan el resto de módulos (Display LCD, SD, RTC) */void setup() { //Serial.begin(9600);//Serial.println("Inicio del registro prueba caja blanca:"); //inicialización de los pines //Serial.println("Inicialización de los pines HOLD, UNITS, RANGO, MAXMIN, CS, EXTRACT,BORRADOR y LED_BUILDIN"); pinMode(HOLD, INPUT); analogWrite(HOLD, LOW); pinMode(UNITS, INPUT); analogWrite(UNITS, LOW); pinMode(RANGO, INPUT); analogWrite(RANGO, LOW);pinMode(MAXMIN, INPUT); analogWrite(MAXMIN, LOW); pinMode(CS, INPUT); pinMode(BORRADOR, INPUT); analogWrite(BORRADOR, LOW); pinMode(LED_BUILTIN, OUTPUT); //Serial.println("Inicialización de los pines completada."); //Serial.println("Inicialización de las interrupciones HOLD, UNITS, RANGO, MAXMIN, EXTRACT y BORRADOR");
61
499500501502503504505506507508509510511512513514515516517
//inicialización de las interrupciones attachInterrupt( digitalPinToInterrupt(HOLD), mantener, FALLING ); attachInterrupt( digitalPinToInterrupt(UNITS), unidades, FALLING ); attachInterrupt( digitalPinToInterrupt(RANGO), rangos, FALLING ); attachInterrupt( digitalPinToInterrupt(MAXMIN), maximoMinimo, FALLING ); attachInterrupt( digitalPinToInterrupt(EXTRACT), extraerConSeguridad, FALLING ); attachInterrupt( digitalPinToInterrupt(BORRADOR), borrado, FALLING ); //En Arduino Due los pines digitales funcionan a 3,3V, por lo tanto no se puede usar la iluminación, por contra podemos disponer de un calibrado del sensor por ejemplo. //attachInterrupt( digitalPinToInterrupt(BOTONLLUM), iluminacion, FALLING ); //invocación de métodos de inicialización del sensor y pantalla calibradoInicial(); inicialicizaPantalla(); inicializaSD(); //inicializando el relog //Serial.println("Inicialización del modulo RTC"); rtc.begin(DateTime(F(__DATE__), F(__TIME__)));//Serial.println("Completada"); //Serial.println("Finalizada la inicialización del Teslametro. Activación de su funcionamiento:");}
/* El cuerpo principal del magnetómetro, realiza una limpieza de pantalla para posteriormente tomar una lectura del sensor actualizando el estado de la struct lecturaSensor, mostrando el valor en pantalla y almacena una linea mas en un txt de la sd. Seguido de un delay, con el tiempo mínimo para que se guarde y se muestre correctamente */ void loop() { currentMillis = millis(); if(currentMillis - previousMillis > tiempo){ previousMillis = currentMillis; digitalWrite(LED_BUILTIN, HIGH); lcd.clear(); //invocación al método principal tratarMuestra(); }else digitalWrite(LED_BUILTIN, LOW); //Serial.println("Finaliza la muestra: "+numMuestra);}
62
63
