REPORTE DE PROYECTO

CARRERA:

Ingeniería en Sistemas Computacionales

NOMBRE DEL PROYECTO:

Sistema inteligente de cortinas por medio de aplicación

Android

INTEGRANTES:

Maldonado Pérez Jorge Alejandro

Pérez Cruz Ángel Horacio

Pérez Santiago José Eduardo

Solórzano Domínguez José Carlos

No. DE CONTROL:

12700181

12700186

12700188

12700196

COMITÁN DE DOMÍNGUEZ, CHIAPAS, 05 DE JUNIO, 2015

TECNOLÓGICO NACIONAL DE MÉXICO

Instituto Tecnológico de Comitán

1

Índice

INTRODUCCION .................................................................................................... 2

CAPÍTULO 1 JUSTIFICACIÓN Y OBJETIVOS ....................................................... 3

1.1 JUSTIFICACION ........................................................................................ 3

1.2 OBJETIVO GENERAL. .................................................................................. 3

1.3 OBJETIVOS ESPECIFICOS. ......................................................................... 3

CAPÍTULO 2 MARCO TEORICO. ........................................................................... 4

2.1 Componentes del sistema de cortina ............................................................. 4

2.1.1 Bluetooth .................................................................................................. 4

2.1.2 Motores CD .............................................................................................. 8

2.1.3 Arduino uno ............................................................................................. 9

2.1.4 Rueda dentada ...................................................................................... 15

2.1.5 Eliminador de corriente ......................................................................... 18

2.1.6 Sensor de presencia fc-51 ..................................................................... 19

2.1.7 Switch o interruptor ................................................................................ 21

2.2 ENTORNOS DE DESARROLLO QUE SE USARON ................................... 22

2.2.1 ARDUINO .............................................................................................. 22

2.2.2 APP INVENTOR .................................................................................... 28

CAPÍTULO 3 RESULTADOS ................................................................................ 40

3.1 Errores generados. ...................................................................................... 40

3.2 Resultado final ............................................................................................. 41

3.3 Los materiales a usar fueron. ....................................................................... 42

3.4 Manual de uso de la aplicación. ................................................................... 43

3.5 Diagrama de la cortina ................................................................................. 46

CAPÍTULO 4 CONCLUSIONES Y RECOMENDACIONES.................................. 47

4.1 Recomendaciones ....................................................................................... 47

4.2 Propuesta de mejora .................................................................................... 48

Bibliografía

2

INTRODUCCION

En el presente proyecto se da a conocer la creación de un sistema inteligente de

movimiento de las cortinas para proyector que se comporta de manera

automatizada a través de una aplicación en la más conocida y eficaz plataforma

para PDA (personal digital assistant, asistente digital personal), es decir, Android.

Esto gracias también a la placa de Arduino ya que permite integrar un módulo de

Bluetooth para la comunicación con cualquier dispositivo que opere con el sistema

operativo Android. Cabe resaltar que no cualquier persona podrá accionar la cortina

pues se tendrá un control de acceso solamente para aquellas personas aptas o con

permisos de usuario garantizando un grado de seguridad.

3

CAPÍTULO 1 JUSTIFICACIÓN Y OBJETIVOS

1.1 JUSTIFICACION

Debido al problema que se tiene al bajar y subir la cortina del proyector, ya que es

tedioso realizar eso cada vez que se utilice el cañón en el Instituto Tecnológico de

Comitán. Se desarrollara un sistema inteligente con una aplicación Android que

facilite ese proceso que se hace todos los días, y así aprovechar la tecnología que

tenemos a la mano.

Cabe destacar que la cortina con el sistema implementado será utilizada por

personas autorizadas a través de una técnica de seguridad que tendrá la aplicación.

1.2 OBJETIVO GENERAL.

Automatizar las cortinas para los proyectores para mejorar la forma en que los

catedráticos y alumnos interactúan en el salón de clases y así puedan disfrutar de

la tecnología a implementar.

1.3 OBJETIVOS ESPECIFICOS.

Facilitar el manejo de las cortinas a través de una aplicación Android, es

decir, el mecanismo en el que sube o baja.

Brindar seguridad al acceder al sistema de cortinas a través de un código de

acceso que la aplicación tendrá.

4

CAPÍTULO 2 MARCO TEORICO.

2.1 Componentes del sistema de cortina

En este capítulo se da a conocer los componentes del sistema inteligente de cortina

para proyector, es decir, la estructura necesaria para que funcione correctamente.

En cada uno de sus partes que lo integran se describe de forma general que es,

como funcionan y que en el capítulo de resultados se describe su estructura física

a través de un diagrama de diseño.

2.1.1 Bluetooth

Bluetooth es una tecnología que se usa de manera cotidiana en distintos

dispositivos y que en el sistema de la cortina inteligente se implementa para el

desarrollo de una aplicación Android que tendrá como fin conectar dispositivos

móviles con la cortina, pero que el acceso lo tendrá el personal autorizado. [1]

Ilustración 1. Modelos de Bluetooth para Arduino. Adaptado de “Bluetooth HC-05 y HC-06 Tutorial de Configuración” por Jesús Rubén.

Los módulos de Bluetooth HC-05 y HC-06 son módulos muy populares para

aplicaciones con microcontroladores PIC y Arduino. Se trata de dispositivos

relativamente económicos y que habitualmente se venden en un formato que

permite insertarlos en un protoboard y cablearlo directamente a cualquier

microcontrolador, incluso sin realizar soldaduras. En esta entrada del blog vamos a

explicar un poco del funcionamiento de estos módulos y como configurarlos.

También abordaremos las diferencias entre el HC-05 y el HC-06.

En la foto de portada del artículo vemos de izquierda a derecha: los módulos HC-

05 y HC-06 en formato amigable para protoboard y un módulo HC-05 en formato

compatible con zócalos para Xbee (módulo Bluetooth bee).

5

2.1.1.1 Diferencias HC-05 vs HC-06 y como identificarlos

Muchas personas y tiendas en internet venden el HC-06 y HC-05 como un mismo

módulo, muchas veces uno pide un HC-05 y terminan vendiéndoles un HC-06. Esto

se debe a que esencialmente el hardware es el mismo para ambos módulos. La

única diferencia real es el firmware que viene cargado de fábrica. De hecho, si

tenemos paciencia, podemos convertir un HC-06 a un HC-05 nosotros mismos con

solamente cambiar el firmware de los módulos, pero quedas advertido: ¡Hay que

construir la interfaz de programación!

Existen unos módulos aptos para insertarse en el protoboard que nos permiten una

fácil identificación del módulo soldado antes de comprar. En estos módulos, los HC-

05 normalmente tienen dos pines extra (además de TX, RX, VCC, GND) etiquetado

como “Key” y “State”. El pin “key” es necesario para entrar al modo de comandos

AT en el módulo HC-05 (pin 34) y por lo tanto, solo se instala cuando el módulo de

Bluetooth a bordo es un HC-05. También podemos identificar si se trata de un HC-

05 por la forma en que se identifican con otros dispositivos Bluetooth: El HC-05 se

identifica como “HC-05″, mientras que el HC-06 se identifica como “Linvor” o “HC-

06″. [1]

Ilustración 2 La fotografía muestra una comparación entre los módulos HC-05 (izquierda) y HC-06 (derecha) en su versión para insertar en protoboard. El HC-05 tiene 2 pines extra. Adaptado de “Bluetooth HC-05 y HC-06 Tutorial de Configuración” por Jesús Rubén.

2.1.1.2 Interfaz de configuración de comandos AT en HC-05

El puerto serie en modo de configuración para el HC-05 debe configurarse de la

siguiente manera: 34800 bps, 8 bits de datos, Sin paridad, Sin control de flujo. Para

entrar al modo de comandos AT seguimos los siguientes pasos:

1. Poner a estado alto en el pin 34 (PIO11)

2. Conectar la alimentación del módulo (o resetearlo de preferencia)

6

3. Enviar un comando AT\r\n para comprobar que estemos en modo de

comando AT.

La siguiente lista es una compilación de los comandos que consideramos

importantes

AT\r\n Comando de prueba, debe responder con OK\r\n

AT+ROLE=1\r\n Comando para colocar el módulo en modo Maestro

(Master)

AT+ROLE=0\r\n Comando para colocar el módulo en modo Esclavo

(Slave)

AT+VERSION?\r\n Obtener la versión del firmware

AT+UART=115200,1,2\r\n Configurar el modo de funcionamiento del

puerto serie en “modo puente”

AT+PIO=10,1\r\n Colocar el pin de IO de propósito general a nivel alto

Existen otros comandos AT que están documentados en la hoja de datos que

proveen nuestros amigos de iTeadStudio. Podemos encontrar la hoja de datos

(datasheet) del HC-05 en la siguiente dirección:

http://biblioteca.geekfactory.mx/Bluetooth_Bee_Pro/datasheet_hc-05.pdf

2.1.1.3 Conexión básica con Arduino

Las conexiones para realizar con Arduino son bastante sencillas. Solamente requerimos colocar como mínimo la alimentación y conectar los pines de transmisión y recepción serial (TX y RX). Hay que recordar que en este caso los pines se debe conectar cruzados TX Bluetooth -> RX de Arduino y RX Bluetooth -> TX de Arduino. La siguiente imagen muestra las conexiones básicas para que funcione el módulo.

Ilustración 3. Conexión de un módulo HC-06 a Arduino. Adaptado de “Bluetooth HC-05 y HC-06 Tutorial de Configuración” por Jesús Rubén.

7

En este caso estamos utilizando el hardware de UART, por lo que la comunicación con la PC no será posible. Para poder utilizar la UART para comunicarse con la PC mediante USB, es necesario utilizar un UART emulado por software, de manera que los pines de comunicación con el módulo Bluetooth queden en pines distintos. [1]

El código para la comunicación a través del Bluetooth es idéntico al que utilizaríamos para comunicarnos con la PC vía USB. El siguiente ejemplo permite encender o apagar el led de la tarjeta Arduino mediante el módulo Bluetooth. El código funciona de la siguiente manera:

Al enviar el carácter E, se pone en estado alto la salida del pin 13 Al enviar el carácter A, se pone en estado lógico bajo la salida 13

Ilustración 4.código para la conexión del módulo Bluetooth. Adaptado de “Bluetooth HC-05 y HC-06 Tutorial de Configuración” por Jesús Rubén.

8

2.1.2 Motores CD

2.1.2.1 ¿Qué es?

Esta máquina de corriente

continua es una de las más

versátiles en la industria. Su fácil

control de posición, par y velocidad

la han convertido en una de las

mejores opciones en aplicaciones

de control y automatización de

procesos. Pero con la llegada de la

electrónica su uso ha disminuido

en gran medida, pues los motores

de corriente alterna, del tipo

asíncrono, pueden ser controlados

de igual forma a precios más

accesibles para el consumidor

medio de la industria. A pesar de

esto los motores de corriente continua se siguen utilizando en muchas aplicaciones

de potencia (trenes y tranvías) o de precisión (máquinas, micro motor, etc.) [2]

Un motor eléctrico de Corriente Continua es esencialmente una máquina que

convierte energía eléctrica en movimiento o trabajo mecánico, a través de medios

electromagnéticos.

Ilustración 6. Partes de un motor de C. D. Adaptado de “Así funciona el motor de corriente directa o continua”

Por: José Antonio E. García Álvarez

Ilustración 5. Componentes de un motor de corriente directa. Adaptado de “Motores de corriente directa (C.D.)”por Sergio R.

9

2.1.2.2 Fundamentos de operación de los motores eléctricos

En magnetismo se conoce la existencia de

dos polos: polo norte (N) y polo sur (S), que

son las regiones donde se concentran las

líneas de fuerza de un imán. Un motor para

funcionar se vale de las fuerzas de atracción

y repulsión que existen entre los polos. De

acuerdo con esto, todo motor tiene que estar

formado con polos alternados entre el

estator y el rotor, ya que los polos

magnéticos iguales se repelen, y polos

magnéticos diferentes se atraen,

produciendo así el movimiento de rotación.

Un motor eléctrico opera primordialmente en base a dos principios: El de inducción,

descubierto por Michael Faraday en 1831; que señala, que si un conductor se

mueve a través de un campo magnético o está situado en las proximidades de otro

conductor por el que circula una corriente de intensidad variable, se induce una

corriente eléctrica en el primer conductor. Y el principio que André Ampére observo

en 1820, en el que establece: que si una corriente pasa a través de un conductor

situado en el interior de un campo magnético, éste ejerce una fuerza mecánica o

f.e.m. (fuerza electromotriz), sobre el conductor.

El movimiento giratorio de los motores de C.C. se basa en el

empuje derivado de la repulsión y atracción entre polos

magnéticos. Creando campos constantes convenientemente

orientados en estator y rotor, se origina un par de fuerzas que

obliga a que la armadura (también le llamamos así al rotor)

gire buscando "como loca" la posición de equilibrio.

Se utilizan en casos en los que es importante el poder regular

continuamente la velocidad del motor, además, se utilizan en

aquellos casos en los que es imprescindible utilizar corriente

directa, como es el caso de motores accionados por pilas o

baterías. Este tipo de motores debe de tener en el rotor y el

estator el mismo número de polos y el mismo número de

carbones. [2]

2.1.3 Arduino uno

El Arduino Uno es una placa electrónica basada en el ATmega328 (datasheet).

Cuenta con 14 pines digitales de entrada / salida (de los cuales 6 se pueden utilizar

como salidas PWM), 6 entradas analógicas, un resonador cerámico 16 MHz, una

conexión USB, un conector de alimentación, un header ICSP, y un botón de reinicio.

Ilustración 8. Representación del giro de un motor.” Motores de corriente directa (C.D.)”. Por Sergio R.

Ilustración 7. Esquema del motor D. C. Motores de corriente directa (C.D.)” por Sergio R.

10

Contiene todo lo necesario para apoyar el microcontrolador; simplemente conectarlo

a un ordenador con un cable USB o el poder con un adaptador de CA o la batería a

CC para empezar.[3]

Ilustración 9.-Arduino uno, adaptado de “ArduinoBoardUno” por arduino

El Uno es diferente de todas las placas anteriores en que no utiliza el chip

controlador de USB a serial FTDI. En lugar de ello, se cuenta con el Atmega16U2

(Atmega8U2 hasta la versión R2) programado como un convertidor de USB a serie.

Revisión 2 de la junta Uno tiene una resistencia tirando la línea 8U2 HWB a tierra,

por lo que es más fácil de poner en modo DFU.

Revisión 3 de la placa tiene las siguientes características nuevas:

1.0 pinout: SDA añadido y pines SCL que están cerca al pin AREF y otros dos

nuevos pasadores colocados cerca del pin de RESET, la instrucción IOREF

que permiten a los escudos para adaptarse a la tensión proporcionada por la

junta directiva. En el futuro, escudos serán compatibles tanto con el tablero que

utiliza el AVR, que opera con 5V y con el Arduino Debido que opera con 3.3V.

El segundo es un pin no está conectado, que se reserva para usos futuros.

"Uno" significa uno en italiano y se nombra para conmemorar el próximo

lanzamiento de Arduino 1.0. El Uno y la versión 1.0 serán las versiones de referencia

de Arduino, moviéndose hacia adelante. El Uno es el último de una serie de placas

Arduino USB y el modelo de referencia para la plataforma Arduino; para una

comparación con las versiones anteriores, consulte el índice de la placa Arduino.

11

2.1.3.1 Resumen

Microcontrolador ATmega328

Voltaje de funcionamiento 5V

Voltaje de entrada (recomendado) 7V

Voltaje de entrada (límites) 6-20V

E / S digital pernos 14 (de los cuales 6 proporcionan salida PWM)

Botones de entrada analógica 6

Corriente DC por E / S Pin 40 mA

Corriente DC de 3.3V Pin 50 mA

Memoria Flash 32 KB (ATmega328) de los cuales 0,5 KB utilizado por el gestor de arranque

SRAM 2 KB (ATmega328)

EEPROM 1 KB (ATmega328)

Velocidad del reloj 16 MHz

Longitud 68.6 mm

Ancho 53.4 mm

Peso 25 g

2.1.3.2 Energía

El Arduino Uno puede ser alimentado a través de la conexión USB o con una fuente

de alimentación externa. La fuente de alimentación se selecciona automáticamente.

Potencia (no USB) externo puede venir con un adaptador de CA a CC (pared-

verruga) o la batería. El adaptador se puede conectar al conectar un enchufe de 2,1

mm de centro-positivo en el conector de alimentación de la placa. Potenciales de

una batería se pueden insertar en los cabezales de pin GND y Vin del conector

POWER.

El tablero puede funcionar con un suministro externo de 6 a 20 voltios. Si se

suministra con menos de 7V, sin embargo, el pin de 5V puede suministrar menos

de cinco voltios y la junta puede ser inestable. Si se utiliza más de 12V, el regulador

de voltaje se puede sobrecalentar y dañar la placa. El rango recomendado es de 7

a 12 voltios.

Los pines de alimentación son como sigue:

VIN. El voltaje de entrada a la placa Arduino cuando se utiliza una fuente de

alimentación externa (por oposición a 5 voltios de la conexión USB u otra fuente de

alimentación regulada). Usted puede suministrar tensión a través de este pin, o, si

12

el suministro de tensión a través de la toma de poder, acceder a él a través de este

pin.

5V.This pin como salida una 5V regulada del regulador en el tablero. El tablero

puede ser alimentado ya sea desde la toma de alimentación de CC (7 - 12 V), el

conector USB (5V), o el pin VIN del tablero (7-12V). El suministro de tensión a través

de los pines de 5V o 3.3V no pasa por el regulador, y puede dañar su tablero. No

aconsejamos ella.

3V3. Un suministro de 3,3 voltios generada por el regulador de a bordo. Empate

Corriente máxima es de 50 mA.

GND. Patillas de tierra.

Instrucción IOREF. Este pin de la placa Arduino proporciona la referencia de tensión

con la que opera el microcontrolador. Un escudo configurado puede leer el voltaje

pin instrucción IOREF y seleccione la fuente de alimentación adecuada o habilitar

traductores de voltaje en las salidas para trabajar con el 5V o 3.3V.

2.1.3.3 Memoria

El ATmega328 tiene 32 KB (con 0,5 KB utilizan para el gestor de arranque).

También tiene 2 KB de SRAM y 1 KB de EEPROM (que puede ser leído y escrito

con la biblioteca EEPROM).

2.1.3.4 Entrada y salida

Cada uno de los 14 pines digitales en la Uno puede ser utilizado como una entrada

o salida, utilizando pinMode (), digitalWrite (), y las funciones digitalRead (). Operan

en 5 voltios. Cada pin puede proporcionar o recibir un máximo de 40 mA y tiene una

resistencia de pull-up (desconectado por defecto) de 20 a 50 kOhm. Además,

algunos pines tienen funciones especializadas:

Serial: 0 (RX) y 1 (TX). Se utiliza para recibir (RX) y transmitir datos en serie (TX)

TTL. Estos pines están conectados a los pines correspondientes de los USB-to-TTL

chips Serial ATmega8U2.

Interrupciones externas: 2 y 3. Estos pines pueden configurarse para activar una

interrupción en un valor bajo, un flanco ascendente o descendente, o un cambio en

el valor. Ver la función attachInterrupt () para más detalles.

PWM: 3, 5, 6, 9, 10, y 11. Proporcionar una salida PWM de 8 bits con la función

analogWrite ().

SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK). Estos pines soportan la

comunicación SPI utilizando la librería SPI.

13

LED: 13. Hay un LED incorporado conectado al pin digital 13. Cuando el pasador

es de alto valor, el LED está encendido, cuando el pasador es bajo, es apagado.

El Uno tiene 6 entradas analógicas, etiquetada A0 a A5, cada una de las cuales

proporcionan 10 bits de resolución (es decir, 1.024 valores diferentes). Por defecto

se miden desde el suelo a 5 voltios, aunque es posible cambiar el extremo superior

de su rango usando el pin AREF y la función analogReference (). Además, algunos

pines tienen funciones especializadas:

TWI: pin A4 o A5 o SDA y SCL pin. Comunicación TWI Apoyo mediante la biblioteca

de alambre.

Hay un par de patas de la placa:

AREF. Tensión de referencia para las entradas analógicas. Se utiliza con

analogReference ().

Restablecer. Traiga esta línea BAJO para reajustar el microcontrolador.

Normalmente se utiliza para añadir un botón de reinicio para escudos que bloquean

el uno en el tablero.

Ver también el mapeo entre los pines de Arduino y puertos ATmega328. La

asignación para el Atmega8, 168, y 328 es idéntico.

2.1.3.5 Comunicación

El Arduino Uno tiene una serie de instalaciones para la comunicación con un

ordenador, otro Arduino, u otros microcontroladores. El ATmega328 ofrece UART

TTL (5V) de comunicación en serie, que está disponible en los pines digitales 0 (RX)

y 1 (TX). Un ATmega16U2 en los canales de mesa esta comunicación en serie a

través de USB y aparece como un puerto com virtual para el software en el

ordenador. El "firmware 16U2 utiliza los controladores USB COM estándar, y no se

necesita ningún controlador externo. Sin embargo, en Windows, se requiere un

archivo .inf. El software de Arduino incluye un monitor de serie que permite a los

datos de texto simples para ser enviados hacia y desde la placa Arduino. Los LEDs

RX y TX de la placa parpadean cuando se están transmitiendo datos a través del

chip y USB a la conexión USB a serie al ordenador (pero no para la comunicación

en serie en los pines 0 y 1).

Una biblioteca SoftwareSerial permite la comunicación en serie en cualquiera de los

pines digitales del Uno.

14

El ATmega328 también es compatible I2C (TWI) y la comunicación SPI. El software

Arduino incluye una biblioteca de alambre para simplificar el uso del bus I2C;

consulte la documentación para obtener más información. Para la comunicación

SPI, utilizar la biblioteca SPI.

2.1.3.6 Programación

El Arduino Uno puede programar con el software de Arduino (descargar).

Seleccione "Arduino Uno desde el menú Herramientas> Junta (de acuerdo con el

microcontrolador en su tablero). Para obtener más información, consulte la

referencia y tutoriales.

Los ATmega328 en la Arduino Uno viene precargado con un gestor de arranque

que le permite cargar nuevo código a él sin el uso de un programador de hardware

externo. Se comunica mediante el protocolo original STK500 (de referencia,

archivos de cabecera C).

También puede pasar por alto el gestor de arranque y programar el microcontrolador

a través del ICSP (In-Circuit Serial Programming) cabecea usando Arduino ISP o

similar; ver estas instrucciones para obtener más detalles.

El ATmega16U2 (o 8U2 en el rev1 y tableros Rev2) código fuente del firmware está

disponible. El ATmega16U2 / 8U2 se carga con un cargador de arranque DFU, que

puede ser activado por:

En las placas Rev1: conectan el puente de soldadura en la parte posterior de la

junta (cerca del mapa de Italia) y luego reiniciar el 8U2.

En las placas Rev2 o posteriores: hay una resistencia que tirando de la línea 8U2 /

16U2 HWB a tierra, por lo que es más fácil de poner en modo DFU.

A continuación, puede utilizar el software de Atmel FLIP (Windows) o el

programador DFU (Mac OS X y Linux) para cargar un nuevo firmware. O puede

utilizar el encabezado de ISP con un programador externo (sobrescribir el gestor de

arranque DFU). Ver este tutorial aportado por los usuarios para obtener más

información.

15

2.1.4 Rueda dentada

Los engranes será utilizados para poder darle fuerza al motor, y así, poder bajar

y subir la pantalla, ya que con estos obtendremos mayor fuerza y reduciremos

velocidad del motor.

Una rueda dentada es un mecanismo de forma circular que transmite movimiento

mediante dientes. Los dientes rodean la rueda en todo su perímetro. Existen

diferentes tipos de ruedas dentadas dependiendo de su forma, colocación de los

dientes; ej. Ruedas dentadas cónicas: helicoidales, cilíndricas, etc. La transmisión

de movimiento entre ejes se tiene que realizar con ruedas dentadas que tengan el

mismo paso y el mismo módulo de dientes. En un sistema de 2 ruedas dentadas

homólogas se llama corona al engrane de mayor diámetro y piñón al de menor

diámetro. Si el eje conductor tiene menor diámetro que el eje conducido se genera

un mecanismo reductor. Si el eje conducido es de menor diámetro se genera un

mecanismo acelerador. [4]

Ilustración 10.Ruedas dentadas o engranes, adaptado de “Ruedas dentadas:deinicion y tipos de engranajes” por Joomla

Objetos que utilizan engranes o ruedas dentadas

Berbiquí Reloj Caja de cambios de un automóvil Diferencial de un automóvil Molino de viento Puerta de garaje

16

2.1.4.1 Tipos de engranaje

Ejes que los paralelos

Engranajes helicoidales sencillos

Ilustración 11.Engrane helicoidales sencillos, adaptado de “Ruedas dentadas:deinicion y tipos de engranajes” por Joomla

Engranaje de doble helicoide

Ilustración 12. Engrane de doble helicoide, adaptado de “Ruedas dentadas:deinicion y tipos de engranajes” por Joomla

Engranajes cilíndricos

Ilustración 13.Engranejes de cilindros, adaptado de “Ruedas dentadas: definición y tipos de engranajes” por Joomla

17

Ejes que se cortan

Cónicos de dientes rectos

Ilustración 14.Engrane cónicos de dientes rectos, adaptado de “Ruedas dentadas: definición y tipos de engranajes” por Joomla

Cónicos de dientes helicoidales

Ilustración 15.Engrane cónicos de dientes helicoidales, adaptado de “Ruedas dentadas: definición y tipos de engranajes” por Jooml

Ejes que se cruzan

De tornillo sinfín

Ilustración 16.Engrane de tornillo de sin fin, adaptado de “Ruedas dentadas: definición y tipos de engranajes” por Joomla

18

2.1.5 Eliminador de corriente

Es un dispositivo llamado eliminador de corriente, también llamada transformador,

ya que aumenta o disminuye el voltaje a través de sus devanados (el número de

vueltas con alambra de cobre en el lado primario y secundario). Lo que ayuda a

disminuir el voltaje de 110 V.A.C a 24,12,9,4,5 y 3 A.C volts, después de bajar la

tensión o voltaje hay que rectificarlo a través de un puente de diodo, una vez que

tengamos el voltaje hay que asegurarnos que aguanta la corriente que te mandara

el aparato.[5]

Ilustración 17. Eliminador de corriente, adaptado de “http://es.wikipedia.org/wiki/Cargador_de_bater%C3%ADas” por mediawiki

En este proyecto, se utilizara un voltaje de 9, ya que es el voltaje soportado por el

motor que se utilizará para poder bajar y subir la cortina, y un voltaje de 5 v para la

alimentación de la placa arduino.

Un cargador de baterías es un dispositivo utilizado para suministrar la corriente

eléctrica o tensión eléctrica que almacenará una o varias simultáneamente pila

recargable o una batería.

La carga de corriente depende de la tecnología y de la capacidad de la batería a

cargar. Por ejemplo, la corriente tensión que debería suministrarse para una recarga

de una batería de auto de 12V deberá ser muy diferente a la corriente para recargar

una batería de 5V de teléfono móvil.

2.1.5.1 Tipos de cargadores

Sencillo

Un cargador sencillo trabaja haciendo pasar una corriente continua o tensión, entre

otras, por ejemplo para la tecnología de plomo constante por la batería que va a ser

cargada. El cargador sencillo no modifica su corriente de salida basándose en el

tiempo de carga de la batería. Esta sencillez facilita que sea un cargador barato,

pero también de baja calidad. Este cargador suele tardar bastante en cargar una

batería para evitar daños por sobrecarga. Incluso así, una batería que se mantenga

mucho tiempo en un cargador sencillo pierde capacidad de carga y puede llegar a

quedar inutilizable.

19

2.1.5.2 Con temporizador

La corriente de salida de un cargador de este tipo se corta tras un tiempo

predeterminado. Estos cargadores fueron los más comunes para baterías NiCd de

alta capacidad a finales de la década de 1990. (Para las pilas de consumo NiCd, de

baja capacidad, se suele usar un cargador sencillo). Es frecuente encontrar a la

venta este tipo de cargadores junto a un paquete de pilas. El tiempo de carga viene

configurado para ellas. Si se utilizan en ellos otras pilas de menor capacidad,

podrían sufrir una sobrecarga. De otro lado, si se cargan pilas de mayor capacidad

que las originales solo quedarán cargadas parcialmente. Los avances en este tipo

de tecnología incrementan la capacidad de las pilas cada década, por lo que un

cargador antiguo puede que solo cargue parcialmente las pilas actuales. Los

cargadores basados en un temporizador tienen también el inconveniente de

provocar sobrecargas en pilas que, aun siendo las adecuadas, no están totalmente

descargadas cuando se ponen a cargar.

2.1.6 Sensor de presencia fc-51

2.1.6.1 Funcionamiento.

La luz del módulo (sensor) se adapta al medio ambiente, que tiene un par de

transmisión y recepción de infrarrojos tubo, tubo de infrarrojos emiten una cierta

frecuencia, al detectar la dirección se encuentran con obstáculos (superficie

reflectante), que se refleja tubo receptor de infrarrojos, después de la procesamiento

circuito comparador, indicador verde se encenderá, en la interfaz de salida de señal

mismo tiempo para la señal digital de salida (una señal de nivel bajo), puede ser a

través de la perilla del potenciómetro de ajuste de la distancia de detección, alcance

efectivo distancia 2 ~ 30cm, voltaje de funcionamiento es 3.3 V a 5V. El rango de

detección del sensor puede ser a través del potenciómetro para ajustar y tienen

pequeña interferencia, fácil de montar, fácil de usar, etc., puede ser ampliamente

utilizado en la evasión de obstáculos robot, vehículo de evasión de obstáculos,

número de líneas, y el seguimiento de la línea blanca y negro y así en muchas

ocasiones. [6]

20

Ilustración 18.Sensor de presencia fc-51, adoptado de “fc-51 sensor de presencia”.

2.1.6.2 Parámetros del módulo.

Cuando el módulo detecta obstáculos en frente de la señal, el indicador verde

en el nivel de luz de placa de circuito y, al mismo tiempo que la señal de bajo

nivel de salida de puerto de salida, el módulo de detección de 2 ~ 30 cm, 35

° de ángulo de detección, distancia de prueba se puede ajustar a través del

potenciómetro, potenciómetro ajustable hacia la derecha, aumenta la

distancia de detección; Hacia la izquierda tuning potenciómetro, se reduce la

distancia de detección.

Los sensores de detección de reflexión infrarroja activa, por lo tanto, la

reflectividad y la forma de la meta es la clave del rango de detección. Blanca

un rango de detección negro, máximo y mínimo; Pequeña zona de la

distancia del objeto, distancia grande.

El puerto de salida OUT módulo de sensor puede ser conectado directamente

al microcontrolador puerto IO puede, también puede conducir un relé de 5V

directamente; Modo de conexión: el VCC - VCC; GND - GND; El OUT - IO

Comparador USOS el LM393, estabilidad de trabajo;

Puede ser utilizado para 3 al poder dc 5v para alimentar el módulo de

alimentación. Cuando en el poder, la luz indicadora de encendido rojo

encendido;

3 mm tornillo agujeros, fácil fijo, instalación;

Circuito tamaño del tablero: los 3.2CM * el 1.4CM

Cada módulo se entrega ya comparar tensión umbral a través del

potenciómetro para ajustar buena, circunstancias especiales, no, por favor,

no ajuste arbitrariamente el potenciómetro.

21

Especificación de la interfaz del módulo

tensión VCC es 3.3V a 5V convertidor (que puede ser conectado

directamente a 5V microcontrolador de un solo chip y 3,3 V)

GND externo

OUT de la interfaz de salida digital pequeña placa (0 y 1)

2.1.7 Switch o interruptor

Un interruptor eléctrico es un dispositivo que permite desviar o interrumpir el curso

de una corriente eléctrica. En el mundo moderno sus tipos y aplicaciones son

innumerables, van desde un simple interruptor que apaga o enciende una bombilla,

hasta un complicado selector de transferencia automático de múltiples capas,

controlado por computadora. [7]

Su expresión más sencilla consiste en dos contactos de metal inoxidable y el

actuante. Los contactos, normalmente separados, se unen mediante un actuante

para permitir que la corriente circule. El actuante es la parte móvil que en una de

sus posiciones hace presión sobre los contactos para mantenerlos unidos.

Ilustración 19. Interruptores, adoptado cd “Interruptor” por Wikipedia

22

2.2 ENTORNOS DE DESARROLLO QUE SE USARON

En este apartado se describe cada uno de los softwares que se usaron para

programar y controlar la cortina realizado, para así dar una explicación del por qué

se usaron y como ayudaron para el desarrollo correcto de los códigos que se

generaron para la forma de actuar de la cortina.

2.2.1 ARDUINO

Para programar la placa es necesario descargarse de la página web de Arduino el entorno de desarrollo (IDE). Se dispone de versiones para Windows y para MAC, así como las fuentes para compilarlas en LINUX. En la Figura 2 se muestra el aspecto del entorno de programación. En el caso de disponer de una placa USB es necesario instalar los drivers FTDI. Estos drivers vienen incluidos en el paquete de Arduino mencionado anteriormente. Existen en las web versiones para distintos sistemas operativos. [8]

Ilustración 20. Entorno de desarrollo.

Lo primero que tenemos que hacer para comenzar a trabajar con el entorno de desarrollo de Arduino es configurar las comunicaciones entre la placa Arduino y el PC. Para ello deberemos abrir en el menú "Tools" la opción "Serial Port". En esta opción deberemos seleccionar el puerto serie al que está conectada nuestra placa. En Windows, si desconocemos el puerto al que está conectado nuestra placa podemos descubrirlo a través del Administrador de dispositivos (Puertos COM & LPT/ USB Serial Port).

El primer paso para comprobar que todo lo que hemos hecho hasta ahora está bien y familiarizarnos con el interfaz de desarrollo, es abrir uno de los ejemplos. Se recomienda abrir el ejemplo "Blink". Para ello debemos acceder a través del menú File (Sketchbook (Examples (Digital (Blink.

23

El ejemplo "Blink" lo único que hace es parpadear un LED que está colocado en el pin número 13 de la placa. Vamos a ver qué hay que hacer para subir el programa a la placa Arduino. Primero comprobamos que el código fuente es el correcto. Para ello pulsamos el botón de verificación de código que tiene forma de triángulo inclinado 90 grados (Figura 3.a). Si todo va bien deberá aparecer un mensaje en la parte inferior de la interfaz indicando "Done compiling". Una vez que el código ha sido verificado procederemos a cargarlo en la placa. Para ello tenemos que pulsar el botón de reset de la placa (Figura 3.b) e inmediatamente después pulsar el botón que comienza la carga (Figura 3.c).

Durante la carga del programa, en la placa USB, se encenderán los LED que indican que se están enviando y recibiendo información por el puerto serie: TX/RX. Si todo se ha realizado correctamente debe aparecer el mensaje "Done uploading". Ahora tan sólo queda esperar unos 8 segundos aproximadamente para comprobar que todo ha salido bien. Si el led colocado en el pin 13 de la placa se enciende y se apaga cada segundo entonces todo ha ido bien. Por fin tenemos todo listo para empezar a trabajar con la placa Arduino.

Ilustración 21.

Figura 3. a) Compilar programa. b) Botón de reset. c) Transferir programa a la placa.

El entorno de desarrollo Arduino contiene un editor de texto para escribir código, un área de mensajes, una consola de texto, una barra de herramientas con botones para funciones comunes, y una serie de menús. Se conecta al hardware Arduino para cargar programas y comunicarse con ellos. [8]

2.2.1.1 Bocetos de escritura

Software escrito utilizando Arduino se llaman bocetos. Estos bocetos se escriben en el editor de texto. Sketches se guardan con él .ino extensión de archivo. Tiene características para cortar / pegar y para buscar / reemplazar texto. El área de mensajes proporciona información mientras que el ahorro y la exportación y también muestra los errores. La consola muestra la salida de texto por el entorno Arduino incluyendo mensajes de error completas y otra información. La esquina derecha inferior de la ventana muestra la actual junta directiva y el puerto serie. Los botones

24

de la barra de herramientas le permiten verificar y cargar programas, crear, abrir y guardar dibujos, y abrir el monitor de serie.

NB: Las versiones del IDE antes de la 1.0 bocetos guardados con él .pde extensión. Es posible abrir estos archivos con la versión 1.0, se le pide que guarde el boceto con la extensión .ino en guardar.

Verificar Comprueba el código de errores.

Subir Compila el código y lo sube a la placa Arduino E / S. Ver la posibilidad de subir los detalles a continuación.

Nota: Si está utilizando un programador externo, puede mantener pulsada la tecla "shift" en su ordenador cuando se utiliza este icono. El texto cambiará a "Subir usando programador"

Nuevo Crea un nuevo boceto.

Abierto Presenta un menú con todos los bocetos en su cuaderno de dibujo. Al hacer clic en uno se abrirá dentro de la ventana actual.

Nota: debido a un error en Java, este menú no se desplaza; si usted necesita para abrir un boceto final de la lista, utilice el menú Archivo | Sketchbook lugar.

Guardar Guarda tu dibujo.

Serial Monitor Abre el monitor serie.

Comandos adicionales se encuentran dentro de los cinco menús: Archivo, Editar, Croquis, Herramientas, Ayuda. Los menús son sensibles al contexto que significa sólo aquellos elementos pertinentes a la labor que está llevando a cabo están disponibles.

2.2.1.2 Editar

Copia para el Foro Copia el código de tu sketch en el portapapeles en una forma adecuada para su publicación en el foro, con coloreado de sintaxis.

Copiar como HTML Copia el código de tu sketch en el portapapeles como HTML, adecuado para incrustar en páginas web.

25

2.2.1.3 Bosquejo

Compruebe / Compile Comprueba el boceto de errores.

Mostrar Sketch Folder Abre la carpeta de dibujo actual.

Agregar Archivo... Añade un archivo de origen en el dibujo (que se copiará desde su ubicación actual). El nuevo archivo aparece en una nueva pestaña en la ventana de dibujo. Los archivos pueden ser retirados del boceto usando el menú de la ficha.

Importar biblioteca Añade una biblioteca para su dibujo mediante la inserción de declaraciones #include en el inicio de su código. Para más detalles, consulte las bibliotecas de abajo. Además, con la versión 1.0.5 y posteriores de la IDE, puede importar una biblioteca de un archivo .zip.

2.2.1.4 Instrumentos

Formato automático Este formato a su código muy bien: es decir, los guiones para que la apertura y cierre de llaves se alinean, y que las sentencias entre llaves se sangra mucho más.

Archivo Sketch Archivos de una copia del dibujo actual en formato .zip. El archivo se coloca en el mismo directorio que el boceto.

Tablero Seleccione la junta que está utilizando. Vea a continuación las descripciones de las diversas juntas.

Puerto Serial Este menú contiene todos los dispositivos serie (real o virtual) en su máquina. Debe actualizar automáticamente cada vez que se abre el menú de herramientas de primer nivel.

Programador Para seleccionar un programador hardware al programar una junta o chip y no utilizar la conexión USB de serie a bordo. Normalmente no será necesario, pero si usted está quemando un gestor de arranque a un nuevo microcontrolador, que va a utilizar esto.

Burn Bootloader Los elementos de este menú le permiten grabar un gestor de arranque en el microcontrolador en una placa Arduino. Esto no es necesario para el uso normal de una placa Arduino, pero es útil si usted compra un nuevo microcontrolador ATmega (que normalmente viene sin un gestor de arranque). Asegúrese de que ha seleccionado la junta correcta en el menú Juntas antes de grabar el gestor de arranque.

26

2.2.1.2 Sketchbook

El entorno Arduino utiliza el concepto de un cuaderno de dibujo: un lugar estándar para almacenar sus programas (o esquemas). Los bocetos en su cuaderno de dibujo se pueden abrir desde el menú Archivo> Sketchbook o desde el botón Abrir de la barra de herramientas. La primera vez que ejecute el software de Arduino, se creará automáticamente un directorio para su cuaderno de dibujo. Puede ver o cambiar la ubicación de la ubicación del cuaderno de dibujo con el cuadro de diálogo Preferencias.

A partir de la versión 1.0, los archivos se guardan con una extensión de archivo .ino. Las versiones anteriores utilizan la extensión .pde. Es posible que todavía .pde abierto llamado archivos en la versión 1.0 y posteriores, el software se cambió de nombre de la extensión a .ino.

Le permite administrar bocetos con más de un archivo (cada uno de los cuales aparece en su propia pestaña). Estos pueden ser archivos normales Arduino código (sin extensión), archivos de C (extensión .c), archivos de C ++ (.cpp), o archivos de cabecera (.h).

2.2.1.3 Carga

Antes de subir tu boceto, es necesario seleccionar los elementos correctos de la Herramientas> Herramientas> Junta y menús del puerto serie. Las tablas se describen a continuación. En el Mac, el puerto serie es probablemente algo así como /dev/tty.usbmodem241 (para una Uno o Mega2560 o Leonardo) o /dev/tty.usbserial-1B1 (para una Duemilanove o anterior placa USB), o / dev / tty .USA19QW1b1P1 0.1 (para un tablero de serie conectado con un adaptador de USB a Serial de Keyspan). En Windows, es probable que sea COM1 o COM2 (para una placa de serie) o COM4, COM5, COM7, o superior (para una placa USB) - para averiguar, buscas dispositivo serie USB en la sección de puertos del Administrador de dispositivos de Windows. En Linux, debería ser / dev / ttyUSB0, / dev / ttyUSB1 o similar.

Una vez que haya seleccionado el puerto serie correcto y tabla, pulse el botón de carga en la barra de herramientas o seleccione el elemento Cargar en el menú Archivo. Placas Arduino actuales se restablecerá automáticamente y comenzará la carga. Con tablas de más edad (pre-Diecimila) que carecen de auto-reset, tendrás que pulsar el botón de reinicio en el tablero justo antes de comenzar la carga. En la mayoría de los tableros, verás un abrir y cerrar de RX y TX LED como el boceto se carga. El entorno Arduino mostrará un mensaje cuando la carga esté completa, o mostrar un error.

Al cargar un boceto, que está utilizando el gestor de arranque de Arduino, un pequeño programa que se ha cargado en el microcontrolador en su tablero. Te permite cargar código sin utilizar ningún hardware adicional. El gestor de arranque está activo durante unos segundos cuando el tablero restablece; entonces empieza

27

el que sea bosquejo fue subido más recientemente al microcontrolador. El gestor de arranque parpadeará el (pin 13) a bordo del LED cuando se inicia (es decir, cuando la placa se reinicia).

2.2.1.4 Bibliotecas

Las bibliotecas proporcionan funcionalidad adicional para uso en bocetos, por ejemplo, trabajar con el hardware o la manipulación de los datos. Para utilizar una biblioteca en un boceto, seleccione en el menú Sketch> Import Library. Esto insertará una o más sentencias #include en la parte superior del boceto y compilar la biblioteca con su boceto. Debido a que las bibliotecas se cargan en el tablero con su dibujo, que aumentan la cantidad de espacio que ocupa. Si un boceto ya no necesita una biblioteca, simplemente eliminar sus declaraciones #include desde la parte superior de su código.

Hay una lista de las bibliotecas en la referencia. Algunas bibliotecas se incluyen con el software de Arduino. Otros pueden ser descargados desde una variedad de fuentes. Desde la versión 1.0.5 del IDE, usted puede importar una biblioteca de un archivo zip y utilizarlo en un boceto abierta. Vea estas instrucciones para instalar una biblioteca de terceros.

Para escribir su propia biblioteca, ver este tutorial.

2.2.1.5 Terceros Hardware

Soporte para hardware de terceros puede ser añadido al directorio de hardware de su directorio de cuaderno de bocetos. Plataformas instaladas puede incluir definiciones de mesa (que aparecen en el menú de a bordo), bibliotecas centrales, bootloaders y definiciones programador. Para instalar, crear el directorio de hardware, luego descomprimir la plataforma de terceros en su propio subdirectorio. (No use "Arduino" como nombre de subdirectorio o tendrá que anular la plataforma integrada Arduino.) Para desinstalar, simplemente borre su directorio.

Para más detalles sobre la creación de paquetes de hardware de terceros, consulte la página de plataformas en el sitio desarrolladores Arduino Google Code.

2.2.1.6 Serial Monitor

Muestra los datos en serie que se envían desde la placa Arduino (USB o tarjeta serie). Para enviar datos a la placa, introduzca el texto y haga clic en el botón "enviar" o pulse enter. Seleccione la velocidad de transmisión del desplegable que coincide con la tasa pasó a Serial.begin en su boceto. Tenga en cuenta que en Mac o Linux, la placa Arduino se restablecerá (volver a ejecutar su dibujo desde el principio) cuando se conecta con el monitor de serie.

También puede hablar con la junta de Procesamiento, Flash, MaxMSP, etc. (ver la página de la interconexión para más detalles). [8]

28

2.2.2 APP INVENTOR

App Inventor es un entorno de desarrollo de aplicaciones para dispositivos

Android. Para desarrollar aplicaciones con App Inventor sólo necesitas un

navegador web y un teléfono o Tablet Android (si no lo tienes podrás

probar tus aplicaciones en un emulador). App Inventor se basa en un

servicio web que te permitirá almacenar tu trabajo y te ayudará a realizar un

seguimiento de sus proyectos. [9]

Se trata de una herramienta de desarrollo visual muy fácil de usar, con la que incluso

los no programadores podrán desarrollar sus aplicaciones.

Al construir las aplicaciones para Android trabajarás con dos herramientas: App

Inventor Designer y App Inventor Blocks Editor. En Designer construirás el Interfaz

de Usuario, eligiendo y situando los elementos con los que interactuará el usuario y

los componentes que utilizará la aplicación. En el Blocks Editor definirás el

comportamiento de los componentes de tu aplicación. [11]

App Inventor permite también ejecutar las aplicaciones en un emulador, por lo que no es imprescindible disponer del teléfono para probar los programas que se hagan.

Ilustración 22. Emulador en Android. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo. *

29

App Inventor fue desarrollado por Google, pero en Agosto de 2011 fue publicado como Software Libre bajo la licencia Apache 2.0 y su desarrollo se traspasó al Instituto Tecnológico de Massachusetts (MIT). El lenguaje de programación que se usa en App Inventor está claramente inspirado y toma muchos elementos de Scratch que está siendo desarrollado por el mismo MIT desde hace más de ocho años.

En la imagen siguiente se puede apreciar la herramienta de diseño en el navegador con la que se construye el interfaz gráfico de la aplicación:

Ilustración 23. Herramienta de diseño de App Inventor. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

2.2.2.1 ¿Por qué App Inventor?

Casi todos los lenguajes de programación tienen una sintaxis que al principiante le suena a chino. Son una mezcla de inglés y extrañas reglas de sintaxis. Como ejemplo, el programa más pequeño que se puede hacer en Java es algo así:

Class Hola public static void main (String [] args)

30

System.out.println ("Hola mundo");

Es evidente que al aprender a programar la sintaxis provoca una curva de aprendizaje significativa. Aunque hay lenguajes más limpios en este sentido que Java, como Python, siempre requiere invertir mucha práctica y tiempo en aprender los comandos, sus reglas de escritura, sentido de los distintos signos de puntuación, etc. Todo este tiempo es tiempo no empleado en aprender a diseñar algoritmos para resolver problemas, tal y como pedía el primero de los objetivos de la asignatura de TIC.

Con App Inventor se aprende a programar usando bloques de programación. Estos bloques están hechos con elementos comunes a la mayoría de los lenguajes de programación existentes. Se colocan bloques para construir bucles, condiciones, variables, etc. que permiten pensar lógicamente y solucionar los problemas de forma metódica, sin perder el tiempo en encontrar el punto y coma o los dos puntos que están donde no deben y producen errores de compilación o ejecución. [12]

Es de esperar que, al igual que hicieron con Scratch, en el futuro los bloques de App Inventor estén traducidos a otros idiomas. En la actualidad sólo están disponibles en inglés, lo que requiere un pequeño esfuerzo de traducción al estudiante para entender qué es lo que hace cada bloque. De todos modos, los bloques están clasificados mediante un criterio de colores que indica en parte su función o el componente al que hacen referencia.

Además de los elementos pedagógicos, App Inventor tiene algunas características que lo hacen especialmente adecuado:

1. Es software libre, no es necesario la adquisición de licencias por parte del profesor y los alumnos

2. Es multiplataforma: requiere sólo de un navegador y la máquina virtual de Java instalada, con “java web start”.

3. Es programación para dispositivos móviles. Los teléfonos y las tabletas están marcando hoy en día buena parte del futuro de la informática y es atractivo para los alumnos poder enseñar en sus propios teléfonos el fruto de su trabajo.

2.2.2.2 Sentencias

Al programar necesitamos a menudo decirle al ordenador que haga algo. En App Inventor existen numerosos bloques que son sentencias de programación. Se distinguen rápidamente porque expresan una acción a realizar con un verbo en imperativo. Los más habituales son call, set y def (abreviatura de define). Además, los bloques que son sentencias sólo están disponibles

Ilustración 24. Algunas sentencias de programación. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

31

en dos colores: azul para modificar variables o propiedades de un objeto y naranja para llamar a funciones. En la imagen siguiente se ven algunos ejemplos de las sentencias para dividir un texto en partes, convertirlo a mayúsculas, cambiar la altura, texto o visibilidad de un recuadro de texto o definir una variable.

2.2.2.3 Condiciones

Con frecuencia necesitamos realizar distintas acciones en función de que ocurra o no algo. En App Inventor para condicionar nuestro programa tenemos las estructuras if-then, if-then-else, while y choose:

En todos estos bloques se puede ver como tenemos en la parte superior un espacio para encajar el test o pregunta que se hace el programa para decidir por donde continuar su flujo. Las tres primeras estructuras son habituales en la mayoría de los lenguajes, la última, choose, es prácticamente igual a if-then-else con la diferencia de que permite devolver una variable en función de que se cumpla o no el test.

2.2.2.4 Bucles

Un bucle provoca la ejecución repetida de varias sentencias. En App inventor disponemos de los bucles while, for range y foreach.

El primero ejecutará el bloque de sentencias que se encajen en el apartado do mientras se cumpla la condición que refleje el test. For range es el típico bucle “for” de otros lenguajes de programación y, como tal, tiene las opciones de elegir el nombre de la variable que itera, su comienzo, fin y el tamaño de los saltos de iteración. Finalmente, foreach es un

Ilustración 25. Bloques de condiciones. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

Ilustración 26. Bloques para realizar bucles o ciclos. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

32

iterador sobre los elementos de una lista.

2.2.2.5 Variables

Disponemos de las herramientas para definir y cambiar variables. El tipo puede ser numérico o un texto y “se declara” al asignarle un valor por primera vez.

En el gráfico anterior se ve cómo se declara una variable llamada “total_alumnos” y se le da un valor numérico de 30. Además se ven dos bloques muy importantes en App Inventor. Su lenguaje cuenta con una estructura de datos llamada list (lista) que es similar a los Arrays de otros lenguajes de programación. Se ve el bloque con el que se define la lista “alumnos” (se define vacía al no añadirle ningún item) y también se ve el bloque en el que se le añaden dos elementos a la lista alumnos. En este ejemplo se le añade el texto que contienen los cuadros de texto “TextBox1” y “TextBox2”.

2.2.2.6 Eventos

Es indispensable que los programas que sean capaces de responder a la interacción del usuario con el interfaz. Es ahí donde toman su importancia los bloques de App Inventor, para ejecutar acciones en respuesta a los eventos que se produzcan en el teléfono o el Tablet.

El nombre de los distintos eventos depende del objeto que los provoca. Un botón avisa de cuando se ha hecho clic sobre él, mientras que el acelerómetro avisa de cuando se ha agitado el móvil, la mensajería de cuando se ha recibido un mensaje, el objeto de Twitter de cuando hemos sido mencionados en esa red social, la cámara de fotos de cuando se ha hecho una foto y así sucesivamente.

Ilustración 27. Realizar variables en App Inventor. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

33

Ilustración 28. Eventos. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

En la imagen anterior se pueden ver algunos de estos eventos. De esta selección se aprecia que con App Inventor no sólo se dispone de objetos que se pueden colocar en la pantalla como un botón o imagen, sino también de otros muchos objetos que nos dan acceso a las funcionalidades que tienen los teléfonos y tablets Android. Tenemos acceso a Internet, Bluetooth, hacer llamadas, enviar y recibir mensajes, las coordenadas de posición GPS, etc.

También se puede apreciar como todos los eventos tienen la estructura “When evento do”, y son de color verde. Tienen este color porque son parte de la sección “My blocks” en el entorno de desarrollo. “My blocks” es donde se leen o manipulan las propiedades de los distintos elementos que hayan sido colocados manualmente en el entorno de diseño: botones, brújula, etiquetas, cuadros de texto, etc.

2.2.2.7 Como usar App Inventor

App Inventor requiere que el ordenador tenga alguno de estos sistemas operativos:

o GNU/Linux: Ubuntu 8+, Debian 5+ o Macintosh (con procesador Intel): Mac OS X 10.5, 10.6 o Windows: Windows XP, Windows Vista, Windows 7

Necesita también de conexión a Internet (los programas y las aplicaciones se cargan siempre desde Internet) y uno de los siguientes navegadores web con estas versiones mínimas:

o Mozilla Firefox 3.6, sin la extensión NoScript instalada o Apple Safari 5.0 o Google Chrome 4.0 o Microsoft Internet Explorer 7

34

Se necesita también una cuenta de correo electrónico de Gmail y Java Web Start instalado en el ordenador.

El software para ejecutar los programas se descarga de http: //appinventor.mit.edu/explore/content/install-app-inventor-software.html, donde se elegirá una opción u otra dependiendo del sistema operativo que se esté usando. En el caso de Macintosh o Windows se dispone del típico instalador para estos entornos

Este software permitirá no solo ejecutar los programas en nuestro móvil o en el emulador, sino que dispone además de un intuitivo interfaz de depuración que ayuda a encontrar errores de programación. Para que App Inventor pueda comunicarse desde el ordenador con el móvil usando el cable USB es necesario ir a los ajustes del móvil ->Opciones de desarrollador y activar la opción “Depuración de USB”.

Importante: Es conveniente instalar este software, pero no necesario para hacer los programas. Si no se instala saldrá un mensaje de error cada vez que se carga la aplicación de desarrollo avisando de que no encuentra el entorno de emulación, pero se puede realizar el programa igualmente.

Se puede apreciar que se trata de una simple vista del listado de proyectos hechos por el usuario. En App Inventor los proyectos se guardan “en la nube”, es decir, en los servidores del MIT. Por tanto, podemos abrir nuestros proyectos desde cualquier ordenador con conexión a Internet sin que tengamos que llevar los archivos de un lado a otro. En cualquier caso, este mismo interfaz da las opciones para descargar el archivo del proyecto si se quiere.

Haciendo clic sobre el botón New, pedirá el nombre que queramos darle al proyecto e inmediatamente se abrirá la siguiente ventana:

35

Ilustración 29.Interfas de inicio de trabajo. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

Se trata de la ventana del diseñador en la que se construye, mediante el ratón, sin necesidad de usar ningún lenguaje de programación, todo el interfaz gráfico que va a tener la aplicación. En ella se han marcado con números cada una de sus partes principales:

1. La paleta contiene todos los elementos que podemos insertar en nuestra aplicación. Hay elementos gráficos como cuadros de texto, botones, lienzo de dibujo (Canvas) y elementos que no se ven en la pantalla del móvil, como base de datos (TinyDB), acelerómetro, cámara de vídeo, etc.

2. Viewer: El visor de la pantalla, simula la apariencia visual que tendrá la aplicación en el móvil. Para añadir un elemento a la pantalla hay que arrastrarlo desde la paleta y soltarlo en el visor. Los elementos que no tengan visibilidad hay que arrastrarlos también al viewer y automáticamente se desplazarán debajo de él bajo el epígrafe “Non-visible components”

3. Components muestra la lista de los componentes que se han colocado en el proyecto. Cualquier componente que haya sido arrastrado y soltado desde la paleta al visor aparecerá ahí. Si se quiere borrar alguno es en la lista de componentes donde está el botón que permite borrarlo.

4. Media muestra las distintas imágenes y sonidos que estarán disponibles para el proyecto. Cualquier archivo de imagen o audio que se quiera usar en la aplicación hay que insertarlo usando este apartado para que esté disponible.

5. Properties: cada vez que en el Viewer se seleccione un componente, en Properties aparecerán todos los detalles que se puedan cambiar de ese componente. Por ejemplo, al hacer clic sobre un componente TextBox se podrá cambiar en Properties su color, texto, fuente, etc. Para aquellos que hayan usado antes entornos de desarrollo del tipo de Visual Studio en Windows o Gambas en Linux le será muy familiar esta forma de trabajar.

36

Tras aceptar el mensaje aparecerá por fin el editor de bloques de programación:

Esta es la pantalla que usaremos para hacer los programas que interaccionan con el interfaz gráfico. Se puede apreciar cómo está dividida en dos partes muy claras: un enorme lienzo en “blanco” a la derecha donde se irán arrastrando los bloques de programación y a la izquierda los menús que dan acceso a esos bloques.

El menú está formado por tres pestañas: Built-In, My Blocks y Advanced, y bajo cada una de ellas aparecen a su vez distintos menús que permitirán seleccionar los bloques disponibles en cada caso.

1. Built-In contiene los bloques que componen el lenguaje de programación propiamente dicho, distribuidos en las secciones Definition, Text, Lists, Math, Logic, Control y Colors.

2. My Blocks ya se ha nombrado anteriormente y contendrá una lista de los elementos que hayan sido colocados en la pantalla Viewer del diseñador para poder acceder mediante el programa a sus propiedades y eventos

3. Advanced es una pestaña que permite acceder de forma global a algunas propiedades comunes a todos los elementos que hemos colocado en el Viewer y que sean de un mismo tipo. Por ejemplo, al colocar un par de botones aparecerá “Any Button” y se podrán cambiar ahí algunas propiedades que afecten simultáneamente a los todos los botones.

En la parte superior derecha del editor de bloques de programación se pueden ver también los botones que dan acceso a conectar con un teléfono Android que estuviera enchufado al ordenador o lanzar el emulador.

2.2.2.8 Programando

La mejor forma de ilustrar la forma de trabajar con App Inventor es mediante un ejemplo hecho paso a paso. En la página oficial hay un enlace bien visible llamado “Teach” donde se puede acceder a decenas de ejemplos y tutoriales de uso. Es casi un clásico empezar con la aplicación “Hello Purr” en la que un gatito maúlla al pulsar en la pantalla. Se pueden encontrar por Internet también ejemplos avanzados.

En lugar de seguir el criterio habitual en los tutoriales que muestran cómo hacer aplicaciones visuales para los móviles, a continuación se expondrá cómo hacer una aplicación con un interfaz sencillo en el que prime más la parte de solución de

Ilustración 30. Editor de bloques. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

37

problemas. Para ello, vamos a hacer el ejercicio típico en los cursos de lenguajes de programación de decir cuál el mayor número de entre tres o más.

Primero hay que hacer el diseño en el navegador, usando el diseñador de App Inventor. En la paleta, en la sección “Screen Arrangement” se escoge un “VerticalArrangement” y se suelta sobre la pantalla del Viewer. El componente VerticalArrangement es para forzar una distribución vertical de los componentes que se suelten sobre él. Así se asegura que la disposición de los elementos en la pantalla es en vertical, independientemente del tamaño y los componentes que pongamos.

Después se añade, sobre el VerticalArrangement1, un TextBox (de la pestaña Basic), un HorizontalArrangement y un Label. Después se añaden dos Button sobre el HorizontalArrangement con lo que se asegura que los botones van a estar siempre colocados uno al lado del otro, en horizontal.

Para que cuando se haga el programa podamos identificar bien los objetos que están en la pantalla es conveniente darles nombres identificativos de su función. Para renombrar los objetos que se han puesto en el paso anterior hay que seleccionarlos en el apartado Components y pulsar el botón Rename. En este programa renombramos el cuadro de texto, los botones y el label a txtInput, btnNuevo, btnFin y lblresultado.

Para este programa vamos a hacer que el txtInput sólo acepte números, por lo que activamos la propiedad NumbersOnly en sus propiedades, tal y como se ve en la imagen anterior.

El interfaz de la aplicación ya está completo, ahora toca hacer el programa mediante el editor del de bloques de programación, que se abrirá pulsando en el botón “Open the Block Editor” del diseñador.

Ilustración 31. Ejemplo de un diseño. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

38

Una vez abierto, para empezar, se definen mediante el bloque que se encuentra en “Built-in” -> “Definition”, dos variables. Una de ellas es una lista a la que se ha llamado lista_numeros. Su bloque se arrastra desde “Built-In”->”Lists”->”make a list”. En esta lista se irán almacenando cada uno de los números que el usuario introduzca cuando quiera comparar varios.

Ilustración 32. Ejemplo de una lista. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

La otra variable se llama máximo y se usará cuando el usuario pulse el botón Fin. En ese momento se recorrerá lista_numeros, se irá comparando cada valor que contiene con el máximo y se irá almacenando ahí el mayor de los números revisados. Como será un número, hay que arrastrarlo desde “Built-in”->”Math-”>number

A continuación se ha programado el evento Click de btnNuevo. Cada vez que el usuario pulse en ese botón se harán los siguientes pasos:

o Añadir el texto de txtInput como un nuevo elemento de lista_numeros o Poner a cero el texto de txtInput o Asegurase de que lblResultado tiene el texto “Introduciendo números”

Es algo tedioso el tener que ir cambiando continuamente de las pestañas de “Built-In” a “My Definitions” porque cada vez que se haga referencia a una variable creada o a un componente colocado en el diseño hay que buscarlo en “My Definitions”, mientras que cada vez que se quiera poner una sentencia, bucle, un número, un texto en blanco o una condición hay que localizarlo en la pestaña “Built-In”. Con la práctica se

hace fácil encontrar cada cosa, pero al principio suele ocurrir que el usuario no encuentra en qué apartado está lo que necesita.

En cualquier caso, como todo el programa se ha hecho arrastrando y soltando bloques no es posible cometer errores de sintaxis. Se puede ver también como, sin

Ilustración 33. Programación de un evento al dar clic. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

39

definir las variables, la aplicación se encarga automáticamente de convertir textos o strings a números y viceversa.

Finalmente podemos probar en nuestro móvil o en el emulador el programa y comprobar si todo ha ido bien. Para ello pulsamos el botón “Connect to Device...” de la esquina superior derecha del editor de bloques y le decimos que transfiera el programa al dispositivo deseado.

Ilustración 34. Ejemplo de un programa terminado comprobado desde el emulador. Adaptado de “Uso de App Inventor en la asignatura de Tecnologías de la Información y la Comunicación”. Por Cesar Vallejo.*

Podemos ir modificando tanto el programa de bloques como el diseño gráfico después de haber conectado al móvil o al emulador y se verá en tiempo real como cambia el diseño de la aplicación en el dispositivo. Además, en caso de que hubiera errores en la lógica del programa que quisiéramos depurar, también existe un sistema de depuración muy completo para poder ver el flujo del programa, valores de variables, etc.

*Las imágenes se obtuvieron de http://appinventor.mit.edu/explore/content/what-

app-inventor.html bajo licencia Creative Commons Reconocimiento-CompartirIgual

3.0

40

CAPÍTULO 3 RESULTADOS

En el siguiente apartado se mostraran las evidencias de la creación y uso de la

cortina inteligente para que los usuarios puedan comprender el cómo y conque

instrumentos fue creada.

3.1 Errores generados.

En primera instancia el material de la cortina que se usó al principio de las pruebas

(una porción de lona gruesa) no fue el material idóneo ya que es muy poco

manejable al enrollarse. Lo que hacía que la cortina se enrollará o desenrollará de

manera no simétrica.

Ilustración 35. Material de lona gruesa.

41

En segunda instancia se realizó unas pruebas con el reed switch que necesita de

un campo electromagnético para funcionar y aun que es económico, es frágil y en

las pruebas se obtuvieron errores ya que necesita que el campo electromagnético

lo roce y quede centrado por lo que no se vio conveniente su implementación.

Ilustración 36. Implementación del reed switch

3.2 Resultado final

Ya como resultado final se cambiaron tanto el reed switch como la lona gruesa; el

reed switch por dos sensores infrarrojos (FC-51) y la lona por un pedazo de mantel.

Y se puso un contra peso en la parte de la cortina que consiste en dos clavos

grandes en la parte de debajo de la cortina. Lo que nos trajo el resultado deseado.

Ilustración 37. Resultado final de la cortina inteligente

Los sensores

infrarrojos

42

3.3 Los materiales a usar fueron.

1. Base de madera.

2. Protoboard.

3. Cables.

4. Arduino uno.

5. Rodillo de una impresora.

6. Tijera.

7. Desarmador.

8. Clavos grandes (se usaron como contrapeso).

9. Un motor DC de 12 volts.

10. Un puente H.

11. 5 Leds.

12. 3 resistencias de 330 ohms.

13. Módulo de bluetooth.

14. Switch.

15. Un regulador de voltaje (LM7809).

16. Un trozo de carpeta (26 x 45 cm aproximadamente).

17. Cinta masking tape.

18. Pasta para soldar.

19. Cautín.

20. Un cargador o adaptador de corriente AC de 12v y 5v.

43

3.4 Manual de uso de la aplicación.

Para hacer uso de este sistema, será necesario tener previamente instalado la

aplicación desarrollada en android, y tener vinculado el modulo bluetooth de la

cortina inteligente al Smartphone.

Esta es la aplicación. La

que tiene el icono del

candado.

Pantalla de inicio de la

aplicación donde se debe

que digitar la contraseña

para poder accesar al

control.

44

Una vez dentro de la

aplicación, dar clic al icono de

bluetooth para seleccionar de

la lista de dispositivos

vinculados el módulo

bluetooth de la cortina

inteligente.

Elegimos la que

termina en HC-06 (En

este ese es el nombre

de bluetooth de la

cortina).

45

Una vez conectado nuestro dispositivo móvil tenemos 4 botones, es decir, cuatro

opciones: desconectar, subir, bajar y salir de la aplicación.

Por ultimo pulsar el botón que

dice conectar. Se sabrá que ya

está conectado cuando el

botón diga desconectar en vez

de conectar. Entonces y solo

entonces la aplicación tendrá el

control de la cortina.

46

3.5 Diagrama de la cortina

L293D

12 v

9 v

5 v

47

CAPÍTULO 4 CONCLUSIONES Y RECOMENDACIONES

Con la implementación del sistema automatizado de la cortina del proyector, el

proceso de bajar y subir la cortina que actualmente se realiza de manera manual,

se logra que esta acción se realice de manera automática (desde el dispositivo

móvil) se evita que la persona autorizada vaya hacia la cortina y realice el trabajo

manual; con esto mejoramos el rendimiento del tiempo y evitamos distracción a los

alumnos, este sistema cuenta con una aplicación Android donde se puede acceder

a través de una contraseña que le será proporcionada por los desarrolladores a los

usuarios finales, al ingresar a la aplicación el usuario tendrá que conectar su

dispositivo móvil con el sistema para poder ser utilizado de manera satisfactoria.

Hubo pruebas fallidas donde los sensores utilizados no funcionan como se espera

cuando se encontraban a un alto grado de luminosidad del sol, debido a que éste

emite infrarrojos, afectando a los sensores. Sin embargo en la vida cotidiana las

cortinas para proyectores se encuentran en aulas bajo un techo que bloquea los

rayos infrarrojos del sol. Por lo que se considera que es recomendable usar los

sensores infrarrojos (RF-51), bajo estas circunstancias.

Una vez terminado el proyecto se realizó una representación a escala de como

funcionaria si esta se llevara a al entorno real y se obtuvo un resultado satisfactorio

pues se implementó las soluciones tecnológicas más convenientes que la

problemática planteada. Ejemplo de ello es la utilización del módulo de bluetooth

que hace que la comunicación entre nuestra cortina y los dispositivos móviles de los

usuarios finales funciones de acuerdo a órdenes que este le decrete.

4.1 Recomendaciones

Para que el sistema automatizado de bajar y subir la cortina con una aplicación siga

funcionando correctamente se recomienda lo siguiente:

No bajar o subir la cortina con la mano.

El usuario final debe ser capacitado antes de utilizar el sistema.

No compartir la contraseña a cualquier persona no autorizada para ingresar

a la aplicación.

No golpear el sistema.

48

4.2 Propuesta de mejora

Para que el proceso se realice de manera totalmente automática, es necesario

implementar nuevos sensores que detecten el consumo de corriente al momento de

encender del proyector y entonces bajar la cortina sin tener ninguna aplicación en

nuestro móvil o botón en el sistema. Cuando el consumo de corriente eléctrica no

corresponda al consumo del proyector encendido, la cortina subirá totalmente

debido a que ya se ha apagado el proyector. Es decir, la cortina actuara de acuerdo

a al estado del proyector.

49

Bibliografía

1. Jesús Rubén (21 de febrero de 2014). Bluetooth HC-05 y HC-06 Tutorial de Configuración - Geek Factory disponible en: http://www.geekfactory.mx/radio/bluetooth-hc-05-y-hc-06-tutorial-de-configuracion/ [ 27 de abril de 2015]

2. Sergio R (25 de octubre 2013).Motor de Corriente Directa. Disponible en: http://www.monografias.com/trabajos74/motores-corriente-directa/motores-

corriente-directa.shtml [2015, 27, Abril]

3. Sitio oficial de Arduino (17 de julio 2014). Arduino uno. Disponible en: http://www.arduino.cc/en/Main/ArduinoBoardUno [1 de mayo de 2015]

4. Joomla(14 de Mayo de 2013).Ruedas dentadas:deinicion y tipos de engranajes.Disponible en: http://www.microlog.net/jml4/index.php/noticias-tecnologia-microlog/124-ruedas-dentadas [ 19 de mayo de 2015]

5. MediaWiki(14 de enero de 2014).Cargador de baterias.Disponible en: http://es.wikipedia.org/wiki/Cargador_de_bater%C3%ADas [ 19 de mayo de 2015]

6. Hurtado Daniel (8 de mayo 2015):Obstacle Avoidance Sensor Module Infrared Module Reflection Phot - Infrared Module - Arduino, 3D Printing, Robotics, Raspberry Pi, Wearable, LED, development boardICStation: Disponible en: http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional [25 de mayo de 2015]

7. Mediawiki (7 de septiembre de 2014). El switch o interruptor en: http://es.wikipedia.org/wiki/Interruptor / [ 27 de mayo de 2015]

8. Sitio oficial de Arduino (17 de julio 2014).Arduino Development Environment. Disponible en: http://www. ARDUINO%20ENTORNO%20DESARROLO.htm [14 de mayo 2015]

9. Ricoy Riego Antonio (17 de octubre 2014).App Inventor en Español. Disponible en: http://www. Primeros%20pasos%20-%20App%20Inventor%20en%20Espa%C3%B1ol.htm [14 de mayo de 2015]