Guia de Aprendizaje

1

2

El presente trabajo es una guía de aprendizaje para el desarrollo de aplicaciones Android y construcción de circuitos de interfaz con el mundo real para su posterior aplicación en robótica móvil. En esta guía contiene el resultado de una investigación de 6 meses de residencia profesional recopilando y probando diferentes métodos, software, pruebas y conclusiones obtenidas a lo largo de este periodo. Se explican los conceptos básicos para familiarizarse con el sistema Android y se desarrollaran aplicaciones básicas y sencillas hasta llegar a las aplicaciones de interfaz con hardware externo que será construido por el lector. Se proporcionan los códigos fuente, esquemáticos, software y demás recursos contenidos en el CD como medio de apoyo. Se han construido dos interfaces para experimentar con Android a través de bluetooth y USB que serán utilizados en las prácticas de igual forma se ha diseñado un robot que servirá de modelo para futuros proyectos y entender mejor los conocimientos adquiridos. Se requieren nociones de programación en algún lenguaje y también el uso de microcontroladores o alguna tarjeta de desarrollo como arduino o similar.

Desarrollos por José Luis Ku Uc Asesorado por Dr. José Ramón Atoche Enseñat Departamento de Ingeniería Eléctrica y Electrónica Agosto de 2012 [email protected] Esta guía fue diseñada para trabajar en computadoras con sistema operativo Windows 7 de 32 bit

3

INTRODUCCIÓN .................................................................................................................................. 4 CONCEPTOS BASICOS.......................................................................................................................... 7 INSTALACION DE LAS HERRAMIENTAS ............................................................................................... 31 JAVA JDK ....................................................................................................................................................31 ANDROID SDK ...........................................................................................................................................35 BASIC4ANDROID ............................................................................................................................ 43 CONFIGURACION DEL ENTORNO DE DESARROLLO ............................................................................. 48 INTRODUCCION A BASIC4ANDROID .................................................................................................. 53 DESARROLLO DE APLICACIONES BASICAS .......................................................................................... 65 DESARROLLO DE APLICACIONES CON LIBRERIAS ................................................................................ 85 CONSTRUCCION DE HARDWARE ..................................................................................................... 119 PIC USB ...................................................................................................................................................119 MODULO BLUETOOTH............................................................................................................................123 IOIO BOARD ............................................................................................................................................127 DESARROLLO DE APLICACIONES DE INTERFAZ ................................................................................. 130 INTERFAZ CON BLUETOOTH ...................................................................................................................130 INTERFAZ CON IOIO ................................................................................................................................145 ROBOT DROID ................................................................................................................................ 154 ESTRUCTURA MECANICA........................................................................................................................154 ELETRONICA ...........................................................................................................................................156 SOFTWARE .............................................................................................................................................162 CONCEPTOS AVANZADOS ............................................................................................................... 167 TEMAS INTERESANTES .................................................................................................................... 187 REPERTORIO DE INSTRUCCIONES DE BASIC4ANDROID ..................................................................... 190 REFERENCIAS .................................................................................................................................. 201

4

¿Qué es un Sistema Operativo? Un sistema operativo es un conjunto de programas, su finalidad es la de gestionar el hardware desde el más bajo nivel, administrar eficazmente los recursos y permitir la interacción con el usuario.

¿Qué es Android? Android es un sistema operativo para dispositivos móviles basado en Linux, desarrollado por Google. La mayor parte de Android está disponible bajo licencia de software libre, esto resulta una opción muy interesante para los fabricantes, para los usuarios y desarrolladores. Android utiliza la arquitectura ARM como hardware principal e integra una variedad de sensores tales como acelerómetros, giroscopios, de proximidad, barómetros, GPS, magnetómetros. Etc. También ofrece conectividad a través de medios alámbricos e inalámbricos como USB, bluetooth, Wi-Fi, NFC, etc. Algunos de estos varían de acuerdo al dispositivo como puede ser una lavadora, un teléfono celular, Tablet, computadora, etc. Desde su lanzamiento ha pasado por varias actualizaciones que corrigen errores y añaden funciones, actualmente el sistema operativo se encuentra en la versión 4.1 (Jelly Bean).

¿Qué es una Aplicación Android? Una aplicación Android es un programa de alto nivel que permite la interacción del usuario con las funciones del sistema operativo y amplía las funcionalidades del dispositivo, la extensión de estas aplicaciones están en formato APK. Las aplicaciones se distribuyen a través del mercado en línea de google llamado Play Store (antes Android Market) para su descarga. También es posible obtener el instalador de la aplicación (archivo APK) y almacenarlo en el dispositivo para su instalación. Otra forma de instalar aplicaciones es a través del propio entorno de desarrollo a través de una conexión USB o Wi-Fi con la computadora.

¿Qué es una máquina virtual? Es un programa que ejecuta código intermedio. Cuando se compila el código el resultado es un conjunto de instrucciones en un formato específico que entiende la propia máquina virtual, un

5

Ejemplo es la máquina virtual Java de Sun Microsystems. En pocas palabras una máquina virtual emula a un ordenador.

¿Qué es la Java JDK? Java JDK (Java Development Kit) es un conjunto de software proporcionado por Sun Microsystems para desarrollar software con el lenguaje de programación java, es utilizado por Android para generar código intermedio que será ejecutado por su propia máquina llamada Dalvik optimizada para funcionar en dispositivos con poca memoria. El sistema Android está basado en lenguaje C++(debido al núcleo Linux) sin embargo se utiliza java por su potencialidad en dispositivos móviles.

¿Qué es la Android SDK? La Android SDK (Software Development Kit) es un conjunto de software proporcionado por Google que provee las herramientas para desarrollar aplicaciones para Android en el lenguaje de programación java. Al utilizar este lenguaje de programación se necesita que la java JDK este instalada en el equipo.

¿Qué se necesita para desarrollar aplicaciones Android? Se necesita el kit de herramientas Java JDK, el kit de herramientas de Google Android SDK y un entorno para desarrollar aplicaciones siendo Eclipse el más popular y poderoso de todos, pero el desarrollo es más lento y complicado ya que está diseñado para un nivel más experto, sin embargo existen alternativas para hacer más fácil el desarrollo de aplicaciones a través de otros entornos como Processing, Mono for Android, Basic4android, App Inventor, etc.

¿Qué es Basic4android? Basic4android es un entorno de desarrollo rápido de aplicaciones Android en lenguaje Basic. Este lenguaje es interpretado por el software que es convertido a código Java para finalmente crear el empaquetado APK.

¿Cómo utilizar Android en Robótica? Un dispositivo Android en Robótica se puede utilizar como un accesorio de un Robot o bien como controlador principal del mismo. Algunas aplicaciones como accesorio puede ser dotar al robot con un sistema de visión a través de la cámara o proporcionarle conexión a internet por medio de Wi-Fi, también utilizarlo como un mando a distancia por bluetooth o para desplegar datos de sensores y proveer una interfaz de usuario con la pantalla táctil, etc. Como controlador principal puede ampliarse la funcionalidad del robot a través de las aplicaciones y hacer operaciones más

6

Complejas ya que se cuenta con un procesador más potente para controlar las funciones principales. De esta forma el robot puede ampliar sus capacidades conectando hardware externo.

¿Cómo conectar Hardware externo a un dispositivo Android? Una parte fundamental del robot son los sensores como sensores de línea, medidores de distancia, sensores de temperatura, de luz ambiente, y actuadores como motorreductores, servomotores, solenoides, válvulas, etc. Para poder establecer una interfaz entre estos y un dispositivo Android es necesario algún medio alámbrico o inalámbrico, casi siempre apoyados de un Microcontrolador. Por ejemplo se puede establecer una interfaz por bluetooth utilizando algún modulo que funcione como puerto serie tales como el HC-05, HC-06, BTM-180, etc. También es posible construir una interfaz a través de Wi-Fi utilizando alguna tarjeta como los shields para arduino. Con la llegada de Android 4.0 se implementó la conectividad NFC que es similar a la tecnología RFID para comunicarse con medios inalámbricos. Una interfaz cableada simple es utilizar la salida de audio para implementar un protocolo de comunicación con algún Microcontrolador. Otra manera de establecer una interfaz es a través del puerto USB por medio del protocolo ADB o ADK, en la que un Microcontrolador actúa como un Host USB. Existen tarjetas dedicadas a aplicaciones con Android tales como IOIO, Arduino USB Host shield, Arduino ADK. Este último el ADK es un protocolo diseñado por google para la conexión de accesorios de hardware pero requiere de la versión Android Gingerbread (2.3.4) o superior para funcionar.

.

7

LAS APLICACIONES ANDROID

COMPONENTES DE UNA APLICACIÓN ANDROID Una aplicación Android puede estar formada básicamente por actividades, servicios, interfaces de usuario e intentos a continuación se definen las más importantes: Activityes: Son componentes de una aplicación que corresponde a una pantalla una actividad es un subprograma, lo análogo a las ventanas de Windows Views: Son los componentes de la interfaz de usuario que permiten interactuar con las aplicaciones Layouts: Son la interfaz de usuario lo análogo a los formularios de Windows Intents: Describen que quiere hacer una aplicación. Es un medio de comunicación con otras aplicaciones. Services: Son código que se ejecuta en segundo plano y no tienen interfaz de usuario. CICLO DE VIDA DE LAS ACTIVITYES Un Proceso es un programa en ejecución que es gestionado por el sistema operativo. Cada aplicación hecha en Basic4android se ejecuta en su propio proceso. Un proceso puede tener también más subprocesos que son útiles para tareas en segundo plano para entender mejor esto se explicara el ciclo de vida de las actividades. Un proceso se inicia cuando el usuario inicia la aplicación, suponiendo que es la primera vez que la aplicación se ejecuta y termina cuando el sistema operativo lo decida, por ejemplo por falta de memoria esto se conoce como asesinar el proceso. Una aplicación de Basic4android está hecha de una o más actividades. Cada actividad cuenta con sus propias variables que pueden ser globales o locales. Las variables locales se declaran en cada subrutina y las variables globales se pueden declarar en las variables de procesos (Process Globals) y las variables de actividad (Activity Globals) Algunos objetos y variables tienen una manera de declararse, más adelante se muestra en los ejemplos.

8

A continuación se explicaran los principales eventos de una actividad: Activity Create: Este sub se llama cuando se crea la actividad. La actividad se crea:   

Cuando el usuario inicia por primera vez la aplicación ha cambiado la configuración del dispositivo (el usuario gira el dispositivo) y la actividad fue destruida Cuando la actividad en segundo plano y el sistema operativo decidió destruirla para liberar memoria.

El propósito principal de este evento o subrutina es cargar o crear la interfaz de usuario e inicializar objetos y variables (entre otros usos), se puede saber si es la primera vez que la aplicación se crea, esto a través del parámetro FirstTime. Activity Resume: Se llama justo después de acabar el evento Activity_Create o reanudar una actividad en pausa (actividad que se trasladó a segundo plano y ahora se vuelve al primer plano). Tener en cuenta que cuando se abre una actividad diferente, la actividad actual primero es pausada y, a continuación, se creará la otra actividad si es necesario y regresa Activity_Pause: Se llama cada vez que la actividad se mueve del primer plano al segundo plano. Esto puede suceder porque: 1. 2. 3. 4.

Se inició una actividad diferente. Se presionó el botón de Home. Un cambio de configuración levantada (se rota el dispositivo por ejemplo). Se presionó el botón Back.

En los escenarios 1 y 2, se interrumpirá la actividad y por ahora se mantiene en memoria en espera para ser reutilizada posteriormente. En el escenario 3 la actividad se interrumpirá, destruirá y creara (y reanudara) nuevamente. En el escenario 4 la actividad se pausara y destruirá. Pulsando el botón back es similar al cierre de la actividad. En este caso no se necesita guardar cualquier información específica Existe un parámetro en Basic4Android llamado UserClosed que será cierto en este último escenario y falso en todos los demás. Se puede utilizar UserClosed para decidir qué datos guardar y también si se desea restablecer cualquiera de las variables de proceso relacionados con su estado inicial.

Cuando se inicie un nuevo proyecto en Basic4android aparecerá una ventana con una actividad y las partes mencionadas anteriormente Process_Globals, Globals, Activity_Create, Activity_Resume y Activity_Pause

9

Figura 1.- Vista general de una actividad en Basic4Android En Basic4Android una Activity tiene las siguientes propiedades: Desde el menú del proyecto:  

Full Screen establece si la actividad ocupa toda la pantalla (la barra de estado del sistema operativo se oculta). Include Title establece si se muestra el título de la actividad

Desde el Diseñador de interfaces:  Drawabble establece el tipo de fondo puede ser un color, un gradiente o un bitmap  Title Color establece el color del titulo  Las dos opciones del menú del proyecto

10

LAS INTERFACES DE USUARIO Los Layout (interfaces de usuario) en Android permiten interactuar con las aplicaciones mediante objetos conocidos como Views (vistas) como lo son etiquetas, botones, cajas de texto, etc. Estas interfaces de usuario se pueden crean desde código XML (en eclipse) requiere de mayor tiempo y conocimientos más profundos del tema. Basic4Android ofrece una herramienta llamada Designer para diseñar las interfaces de usuario de una manera rápida y sencilla, a continuación se describen las principales características de los Layout y los Views 1. Button

El Button (botón) es un View muy común y utilizado en las interfaces de usuario Principales eventos: Clic cuando el usuario toca el Button Principales propiedades comunes: Enabled habilita o deshabilita el Button Text establece el texto del Button Visible esconde o muestra el Button Principales propiedades especiales: Drawable establece el estilo grafico del Button (por default o configurable)

2.

CheckBox

El CheckBox (caja de verificación) es un View utilizado para marcar o seleccionar opciones

11

Principales eventos: CheckedChange cuando el CheckBox cambia de estado Principales propiedades comunes: Enabled habilita o deshabilita el CheckBox Text establece el texto del CheckBox Visible esconde o muestra el CheckBox Principales propiedades especiales: Checked establece si estará marcado por default (se utiliza también para saber si esta seleccionado)

3. EditText

El EditText (Texto Editable) es un View utilizado como entrada de caracteres al hacer clic en el aparece el teclado de Android para introducir datos generalmente no se usan eventos. Principales eventos: TextChanged cuando el usuario toca el EditText EnterPressed cuando se presiona la tecla enter Principales propiedades comunes: Enabled habilita o deshabilita el EditText Text establece el texto del EditText Visible esconde o muestra el EditText Principales propiedades especiales: PassWord establece si se usa el modo contraseña SingleLine establece si se usa el modo de solo una línea

12

InputType elige el tipo de entrada (letras, números, etc.)

4. ImageView

El ImageView (Vista de imagen) es un View muy común y utilizado para desplegar imágenes también puede ser utilizado como botón. Principales eventos: Clic cuando el usuario toca el ImageView Principales propiedades comunes: Enabled habilita o deshabilita el ImageView Visible esconde o muestra el ImageView Principales propiedades especiales: ImageFile indica la imagen que contendrá el ImageView Gravity establece la forma de contener la imagen (centro, estrecho, etc.)

5. Label

El Label (Etiqueta) es un View muy común y utilizado para desplegar texto pero al igual que el ImageView puede ser utilizado como botón. Principales eventos: Click cuando el usuario toca el Label

13

Principales propiedades comunes: Enabled habilita o deshabilita el Label Visible esconde o muestra el Label Principales propiedades especiales: Text Style configura el tipo de fuente, tamaño, color, etc. Drawable establece el estilo grafico del Label

6. ListView

El ListView (Vista de lista) es un View utilizado para presentar una lista de elementos seleccionables llamados ítems. Los elementos de la lista se construyen desde código Principales eventos: ItemClick cuando el usuario toca algún elemento del ListView Principales propiedades comunes: Enabled habilita o deshabilita el ListView Visible esconde o muestra el ListView Principales propiedades especiales: Drawable establece el estilo grafico del ListView

14

FastScroollEnabled Habilita o deshabilita la barra de desplazamiento rápido cuando se desliza el ListView

7. Panel

El Panel (Tablero) es un View utilizado para agrupar Views. Principales eventos: Touch cuando el usuario toca el Panel (coordenadas) Principales propiedades comunes: Enabled habilita o deshabilita el Panel Visible esconde o muestra el Panel Principales propiedades especiales: Drawable establece el estilo grafico del Panel

8.

ProgressBar

El ProgressBar (Barra de avance) es un View utilizado para mostrar el avance de alguna operación o alguna cantidad en forma de barra como por ejemplo en una descarga. Principales eventos: No tiene eventos Principales propiedades comunes:

15

Enabled habilita o deshabilita el ProgressBar Visible esconde o muestra el ProgressBar Principales propiedades especiales: Indeterminate establece el estilo grafico del ProgressBar Progress establece el avance del ProgressBar (accesible solo desde código)

9. RadioButton

El RadioButton (Radio-Botón) es un View utilizado para marcar o seleccionar opciones cuando hay varios RadioButton existe una agrupación si están dentro de un panel solo se puede seleccionar uno si existe otro fuera del panel también se puede seleccionar pero no se podrá seleccionar otro que este en el mismo grupo que este último. Por ejemplo es útil cuando selecciona un dispositivo bluetooth para emparejarse ya que solo se puede emparejar con uno a la vez. Principales eventos: CheckedChange cuando el RadioButton cambia de estado Principales propiedades comunes: Enabled habilita o deshabilita el RadioButton Text establece el texto del RadioButton Visible esconde o muestra el RadioButton Principales propiedades especiales: Checked establece si estará marcado por defualt (se utiliza también para saber si esta seleccionado)

10. SeekBar

16

El SeekBar (Barra de búsqueda) es un View deslizable para controlar numéricamente una acción, por ejemplo para cambiar el brillo de la pantalla o el volumen de audio. Es lo contrario al ProgressBar Principales eventos: ValueChanged cuando el SeekBar cambia de posición Principales propiedades comunes: Enabled habilita o deshabilita el ProgressBar Visible esconde o muestra el ProgressBar Principales propiedades especiales: MaxValue establece el valor máximo que puede tomar (tipo entero) Value establece el avance del SeekBar (se usa también para saber la posición)

11. Spinner

El Spinner (Hilandero) es un View tipo lista conocido en el ambiente Visual Basic como ComboBox tiene un funcionamiento similar al ListView, pero a diferencia de este la lista de ítems se despliega hasta hacer tocar la flecha. Los elementos de la lista se construyen desde código Principales eventos: ItemClick cuando el usuario toca algún elemento del Spinner Principales propiedades comunes: Enabled habilita o deshabilita el Spinner Visible esconde o muestra el Spinner Principales propiedades especiales: Prompt establece el título que aparecerá cuando la lista de ítems se despliega (Spinner abierto)

17

12. TabHost

El TabHost (Huésped de pestañas) es un View utilizado para mostrar varias pestañas cada una con su propia interfaz de usuario. Es útil cuando la cantidad de información que se quiere mostrar no alcanza en la pantalla. Cada pestaña requiere de un Layout. Principales eventos: TabChanged cuando el usuario toca una pestaña diferente Principales propiedades comunes: Enabled habilita o deshabilita el TabHost Visible esconde o muestra el TabHost Principales propiedades especiales: Solo son accesibles desde código

13. ToggleButton

El ToggleButton (botón conmutador) es un View similar al Button tradicional pero con la característica que cuando se toca hace un cambio de estado (como un CheckBox). Cuenta también con un gráfico para indicar su estado. Principales eventos: CheckedChange cuando el usuario toca el ToggleButton

18

Principales propiedades comunes: Enabled habilita o deshabilita el ToggleButton Visible esconde o muestra el ToggleButton Principales propiedades especiales: Checked establece el estado por defualt (se utiliza también para saber el estado) Text On establece el texto a mostrar cuando el estado del ToggleButton es verdadero Text Off establece el texto a mostrar cuando el estado del ToggleButton es falso

14. WebView

El WebView (Vista Web) es un View usado para funciones de navegación como mostrar una página de internet, permite también el uso de JavaScript. Principales eventos: PageFinished este evento se ejecuta después de que la página es cargada por completo Override Url este evento se ejecuta antes de cargar cualquier Url Principales propiedades comunes: Enabled habilita o deshabilita el WebView Visible esconde o muestra el WebView Principales propiedades especiales:

19

JavaScriptEnabled habilita o deshabilita el uso de JavaScript ZoomEnabled habilita o deshabilita el zoom en el WebView

Cuando el usuario ha terminado de diseñar su interfaz de usuario el resultado final que contiene todos los Views agregados al diseño y las configuraciones establecidas es llamado Layout. El diseño de un Layout puede realizarse desde la herramienta Designer para facilitar el proceso, a partir de este punto se cuenta con dos opciones: la primera es crear el Layout con el emulador y la segunda desde el dispositivo conectado a la PC por USB o en red.

A continuación se describen las partes más importantes en el sistema operativo con respecto a la pantalla de usuario:

20

LA PANTALLA PRINCIPAL 1. Status Bar (barra de estado) en esta área se despliegan los iconos indicadores de batería, red, hora, etc. Las notificaciones también aparecen en esta área. 2. Widgets son pequeñas aplicaciones en pantalla con una interfaz de usuario limitada y reducida. 3. Lanzador de aplicaciones al tocar el icono se mostraran todas las aplicaciones instaladas (este es un claro ejemplo de cambio de activity ya que se cambia de pantalla) 4. Dock en esta área se aloja el icono lanzador de aplicaciones y otros accesos directos. 5. Home esta es la pantalla principal

EL DISEÑADOR EN EL EMULADOR Para un layout existen dos orientaciones de pantalla Portrait y Landscape presionando Ctrl + F11 cambiara la orientación del emulador para poder diseñar la interfaz de usuario.

Figura 2.- Orientación de pantalla Landscape (izquierda) y Portrait (Derecha)

Cuando el usuario ha terminado de diseñar su interfaz de usuario el siguiente paso es guardar el Layout con un nombre sin usar espacios ni caracteres especiales.

21

LOS INTENTS Y SERVICIES Aun con todas las funciones básicas e interfaces de usuario no es suficiente para desarrollar potentes aplicaciones como sucede en el caso de la programación de microcontroladores o en los programas de computadora ya que en estos es necesario el uso de interrupciones para hacer funciones multitarea y aprovechar al máximo los recursos. Android proporciona ciertas funciones que complementan las aplicaciones y representan la mayor parte de la potencialidad del sistema operativo los Intents y los Servicies. Los Intent son un medio para comunicar aplicaciones entre sí de esta forma intercambian información en un formato único con ciertos parámetros. Por ejemplo cuando se toca un vínculo que está en una aplicación, emerge una ventana donde presenta las aplicaciones que pueden mostrar la página (navegadores como opera mini o la aplicación de internet), en ese momento se ejecuta un Intent que pasara como parámetros a la aplicación seleccionada la Url de la página a visitar. Los Servicies se definieron anteriormente como código que se ejecuta en segundo plano y no tiene interfaz de usuario. Anteriormente se explicó el ciclo de vida de las actividades y estas se destruyen al presionar la tecla back, Los servicios a diferencia pueden estarse ejecutando sin necesidad de estar en alguna aplicación y se puede estar haciendo otras tareas. Por ejemplo el usuario puede estar navegando, jugando o escribiendo un mensaje de texto, incluso cuando el teléfono está en reposo. En algún momento el sistema avisara al usuario que ha recibido un nuevo correo electrónico, o tiene una notificación de Facebook, Esto es posible gracias a los servicios ya q no es necesario estar en la aplicación de Facebook para recibir una notificación, Sin embargo al tocar la notificación en la barra de estado se lanzara una aplicación. Las notificaciones de Android son el medio en que los servicios interactúan con el usuario y con las aplicaciones.

CONFIGURACION DE LAS APLICACIONES Las aplicaciones en Android requieren de configuraciones especiales para ser distribuidas, en estas configuraciones se debe especificar la versión de Android a utilizar, nombre del paquete, orientación de pantalla soportada, permisos, firmas, versión, icono, etc. Basic4android ha simplificado esta tarea ya que por ejemplo al incluir una librería en nuestro proyecto automáticamente los permisos se agregan al archivo de configuración conocido como Android Manifest. Estas se pueden configurar desde el menú Project a continuación se explicara las configuraciones necesarias para las aplicaciones desarrolladas en Basic4Android.

22

Full Screen

Marcando esta opción la barra de estado permanecerá oculta y la aplicación ocupara toda la pantalla Include Title

Marcando esta opción se muestra el título de la aplicación Choose Icon

Por medio de esta opción se selecciona el icono usado por la aplicación puede ser un archivo de imagen BMP, JPG, GIF, PNG. Package Name

Es un nombre en formato algo.algo por ejemplo miaplicacion.android, es un identificador único para la aplicación, no puede contener espacios ni caracteres especiales.

23

Application Label

Es el título que parece debajo del icono de la aplicación se permite el uso de espacios Versión

Se requiere un número en entero para indicar la versión de la aplicación y una cadena de texto por ejemplo: Version Code: 1, Version String: Beta Can Install To External Storage

Seleccionando esta opción la aplicación se instalara en el almacenamiento externo (memoria SD) útil en dispositivos con poca memoria interna. Es importante no usar esta opción si la aplicación proporciona Widgets y utiliza Servicies.

24

Orientations Supported

Selecciona la orientación de la aplicación puede ser Portrait (Retrato), Landscape (Paisaje) y Both (Ambos). Si se elige Portrait permanecerá así a pesar de rotar el dispositivo. Si se elige Landscape permanecerá así a pesar de rotar el dispositivo. Si se elige Both la aplicación Rotara si el dispositivo rota y si tiene activada la rotación automática.

CONCEPTOS DE ELECTRONICA

MICROCONTROLADORES

Un Microcontrolador es un circuito integrado (Chip) programable, en otras palabras es una pequeña computadora que necesita de hardware externo de entrada y salida. Las entradas pueden ser: sensores, interruptores, teclados, etc. Las salidas pueden ser: LED’s, Pantallas, Relevadores, Zumbadores, etc. Por medio de un software se diseña el programa para el Microcontrolador en algún lenguaje como Basic, C, ensamblador, etc. En la actualidad los microcontroladores son la herramienta fundamental para el desarrollo científico y tecnológico, saber sobre estos dispositivos electrónicos es muy importante ya que se encuentran en la mayoría de las cosas desde un juguete hasta un transbordador espacial. Actualmente existen herramientas generales de hardware y software que facilitan el diseño con microcontroladores, reducen el tiempo, la complejidad, el costo, etc. Entre ellos destacan software de alto nivel como CCS, PIC BASIC, PROTON, MIKROC, etc. Pero existen además herramientas específicas que facilitan aún más el proceso de desarrollo tal es el caso de plataformas como Arduino, Pingüino, Basic Stamp, Picaxe, etc.

25

MICROCONTROLADORES PIC

Los PIC son una familia de microcontroladores fabricados por Microchip Technology Inc. Para transferir el código de un ordenador al PIC normalmente se usa un dispositivo llamado programador. Microchip proporciona un entorno de desarrollo freeware llamado MPLAB que incluye un simulador software y un ensamblador. Otras empresas desarrollan compiladores C y BASIC. ARDUINO

Arduino es una plataforma de electrónica abierta para la creación de prototipos basada en software y hardware flexibles y fáciles de usar. Se creó para artistas, diseñadores, aficionados y cualquiera interesado en crear entornos u objetos interactivos. Arduino puede tomar información del entorno a través de sus pines de entrada de toda una gama de sensores y puede afectar aquello que le rodea controlando luces, motores y otros actuadores. El microcontrolador en la placa Arduino se programa mediante el lenguaje de programación Arduino (basado en Wiring) y el entorno de desarrollo Arduino (basado en Processing). Los proyectos hechos con Arduino pueden ejecutarse sin necesidad de conectar a un ordenador, si bien tienen la posibilidad de hacerlo y comunicar con diferentes tipos de software (p.ej. Flash, Processing, MaxMSP). Las placas pueden ser hechas a mano o compradas montadas de fábrica; el software puede ser descargado de forma gratuita

26

PINGÜINO

Pingüino es una plataforma de desarrollo similar a Arduino, pero basada en microcontrladores PIC. Es compatible con microcontroladores de 8 y de 32 bits, todos con USB integrado (sin chip FTDI). Pingüino viene con un cargador de arranque USB. Este pequeño programa que se ejecuta dentro del microcontrolador es responsable de transferir la aplicación desde la PC a la memoria del microcontrolador. Las tarjetas Pingüino se pueden utilizar de diferentes maneras dependiendo de las habilidades del usuario: Con el IDE Pingüino y el Lenguaje Pingüino (basado en C y casi compatible con el lenguaje Arduino) con © Microchip MPLAB X IDE ©. Pingüino es un entorno de desarrollo integrado (IDE), que da a todos la capacidad de escribir, compilar y cargar programas en una tarjeta Pingüino. El lenguaje Pingüino es casi compatible con el lenguaje Arduino, Bibliotecas y Shields. PICAXE

El sistema PICAXE es un sistema de programación de microcontroladores poderoso, pero muy económico, diseñado para el uso educativo y aficionado de los microcontroladores Una de las características únicas del sistema PICAXE es que los programas pueden descargarse directamente al microcontrolador mediante un cable conectado al mismo, por lo tanto no se requiere el uso de equipos programadores/eliminadores de alto costo. Además, el software es fácil de utilizar y gratis; por lo tanto los estudiantes pueden trabajar sus proyectos utilizando el sistema de programación completo en casa. Los programas pueden crearse ya sea gráficamente utilizando organigramas, o programando utilizando un lenguaje BASIC sencillo incluido en el software.

27

PERIFERICOS En informática, se denomina periféricos a los aparatos y/o dispositivos auxiliares e independientes conectados al CPU de una computadora. Se consideran periféricos tanto a las unidades o dispositivos a través de los cuales la computadora se comunica con el mundo exterior y que permitan realizar operaciones de entrada/salida. En los microcontroladores los periféricos realizan la misma tarea, pero están implementados dentro del mismo chip. Los periféricos pueden clasificarse en 3 categorías principales:   

Periféricos de entrada: captan información del mundo exterior. Periféricos de salida: son dispositivos que muestran o proyectan información hacia el mundo exterior Periféricos de entrada/salida (E/S): sirven básicamente para la comunicación con el medio externo. Entre los periféricos más comunes implementados en los microcontroladores se pueden encontrar: ADC’s: Convertidores Analógico a Digital, generalmente usado para obtener la información de sensores. PWM’s: Moduladores de ancho de pulso, generalmente usado para controlar la intensidad y velocidad de ciertas cargas como focos y motores. DAC’s: Convertidores de Digital a Analógico, es un dispositivo para convertir datos digitales en señales de corriente o de tensión analógica. UART: Transmisor-Receptor Asíncrono Universal, es un medio para la comunicación con otros microcontroladores o dispositivos.

SENSORES Y ACTUADORES Un sensor es un dispositivo capaz de detectar magnitudes físicas o químicas y transformarlas en magnitudes eléctricas, Los sensores trasladan la información desde el mundo real al mundo abstracto de los microcontroladores. Existen diferentes tipos de sensores pueden ser mecánicos, ópticos, sónicos, magnéticos, piezoeléctricos, etc. Estos dispositivos proporcionan información del mundo real como la temperatura, la presión, la iluminación, aceleración, fuerza, etc.

28

Un actuador es un dispositivo capaz de convertir energía hidráulica, neumática o eléctrica en la activación de un proceso con la finalidad de generar un efecto sobre un proceso automatizado, son muy utilizados en los aparatos mecatrónicos, como por ejemplo, en los robots. Los motorreductores, servomotores, solenoides, etc. son los más utilizados en robótica.

BLUETOOTH Bluetooth es una especificación industrial para Redes Inalámbricas de Área Personal (WPAN) que posibilita la transmisión de voz y datos entre diferentes dispositivos mediante un enlace por radiofrecuencia en la banda ISM de los 2,4 GHz. Los principales objetivos que se pretenden conseguir con esta norma son:

  

Facilitar las comunicaciones entre equipos móviles y fijos. Eliminar cables y conectores entre éstos. Ofrecer la posibilidad de crear pequeñas redes inalámbricas y facilitar la sincronización de datos entre equipos personales.

Los dispositivos Bluetooth se clasifican como "Clase 1", "Clase 2" o "Clase 3" en referencia a su potencia de transmisión, siendo totalmente compatibles los dispositivos de una clase con los de las otras.

Clase

Potencia máxima permitida Potencia máxima permitida Rango (mW) (dBm) (aproximado)

Clase 1 100 mW

20 dBm

~100 metros

Clase 2 2.5 mW

4 dBm

~10 metros

Clase 3 1 mW

0 dBm

~1 metro

29

Los dispositivos Bluetooth también pueden clasificarse según su ancho de banda:

Versión

Versión 1.2

Ancho de banda

1 Mbit/s

Versión 2.0 + EDR 3 Mbit/s

Versión 3.0 + HS 24 Mbit/s

Versión 4.0

24 Mbit/s

Para utilizar Bluetooth, un dispositivo debe implementar alguno de los perfiles Bluetooth. Estos definen el uso del canal Bluetooth. Así como canalizar al dispositivo que se quiere vincular. Un perfil Bluetooth es la especificación de una interfaz de alto nivel para su uso entre dispositivos Bluetooth. Para utilizar una cierta tecnología Bluetooth un dispositivo deberá soportar ciertos perfiles.

Algunos perfiles de Bluetooth son: Advanced Audio Distribution Profile (A2DP) Distribución de audio avanzada. Define cómo se puede propagar un stream de audio entre dispositivos a través de una conexión Bluetooth. File Transfer Profile (FTP) Transferencia de ficheros. Da acceso remoto a los sistemas de ficheros, permitiendo listados de directorios y cambios a éstos, obtención, envío y borrado de ficheros Human Interface Device Profile (HID) Dispositivo de interfaz humana. Da soporte a dispositivos tales como ratones, joysticks y teclados.

30

Serial Port Profile (SPP) Puerto serie. Basado en la especificación 07.10 de ETSI por medio del protocolo RFCOMM. Emula una línea serie y provee una interfaz de reemplazo de comunicaciones basadas en RS-232, con las señales de control típicas

USB OTG USB On-The-Go, es una extensión de la norma USB 2.0 que permite a los dispositivos USB tener más flexibilidad en la gestión de la conexión USB. Permite que dispositivos como un reproductor de audio digital o teléfono móvil actúen como host, por lo que se les puede conectar un pendrive, un ratón, un teclado, un disco duro, etc....

31

1.- Descargar e instalar JAVA JDK Link de descarga: http://www.oracle.com/technetwork/java/javase/downloads/jdk-6u26-download-400750.html El instalador también se encuentra en la carpeta TOOLS del CD Aceptar los términos y después dar clic al archivo marcado en rojo para comenzar la descarga

Figura 1.- Descarga de JAVA JDK

32

Buscar el archivo descargado y ejecutar como administrador

Figura 2.- Ejecutar como administrador Hacer clic en siguiente

Figura 3.- Ventana de bienvenida

33

Hacer clic en siguiente

Figura 4.- Opciones de instalación Esperar que termine la instalación de JAVA JDK 6

Figura 5.- Instalación en curso

34

Hacer clic en finalizar

Figura 3.- Instalación completa Continuar con el paso 2

35

2.- Descargar, Instalar y Configurar ANDROID SDK Link de descarga http://developer.android.com/sdk/index.html El instalador también se encuentra en la carpeta TOOLS del CD Hacer clic en el botón marcado en rojo para comenzar la descarga

Figura 6.- Descarga de ANDROID SDK

36

Buscar el archivo descargado y ejecutar como administrador

Figura 7.- Ejecutar como administrador Hacer clic en siguiente

Figura 8.- Ventana de bienvenida

37

Hacer clic en siguiente

Figura 8.- JAVA JDK encontrada Hacer clic en siguiente

Figura 9.- Ruta de instalación

38

Hacer clic en siguiente

Figura 10.- Comienzo de la instalación Hacer clic en siguiente

Figura 11.- Instalación completada

39

Hacer clic en finalizar y esperar que se ejecute el SDK MANAGER

Figura 12.- Ejecución del Asistente

40

Seleccionar los componentes Android SDK Platform-tools, SDK Platform y Google USB Driver marcados en rojo y hacer clic en instalar.

Figura 13.- Selección de componentes Marcar aceptar todos y Hacer clic en instalar

Figura 14.- Aceptar Términos

41

Ir a la ruta de instalación de ANDROID SDK y encontrar la carpeta Platform-tools

Figura 15.- Carpeta Platform-tools Copiar la carpeta Platform-tools y pegar en la carpeta Platforms->Android-8

Figura 16.- Copiar y Pegar Platform-tools

42

Renombrar la carpeta pegada quedando como tools

Figura 17.- Carpeta Platform-tools renombrada NOTA: para la instalación simple copiar en archivos de programa la carpeta ANDROID contenida en la carpeta TOOLS del CD Continuar con el paso 3

43

3.- Descargar, Instalar y Configurar Basic4Android Link de descarga http://www.basic4ppc.com/android/downloads.html

Hacer clic en el enlace marcado en rojo para comenzar la descarga

Figura 18.- Descarga de Basic4Android

44

Buscar el archivo descargado y ejecutar como administrador

Figura 19.- Ejecutar como administrador Hacer clic en siguiente

Figura 20.- Ventana de bienvenida

45

Marcar aceptar los términos y hacer clic en siguiente

Figura 21.- Términos del software Hacer clic en siguiente

Figura 22.- Ruta de instalación

46

Marcar crear acceso directo y Hacer clic en siguiente

Figura 23.- Creación de acceso directo Hacer clic en instalar

Figura 24.- Comienzo de la instalación

47

Marcar ejecutar Basic4Android y hacer clic en finalizar.

Figura 25.- Instalación finalizada

Nota: Es necesario activar la versión completa para ello copiar en la raíz de la carpeta donde se instaló Basic4Android el archivo b4a-license que está en la carpeta TOOLS-> Basic4android 1.5 del CD, después repetir el proceso de instalación y ejecutar Basic4android e introducir el correo contenido en el archivo clave que está en la carpeta TOOLS-> Basic4android 1.5 del CD, copiar en la raíz de la carpeta donde se instaló Basic4Android las carpetas Libraries y Bibliotecas adicionales que están en la carpeta TOOLS-> Basic4android 1.5 del CD. Al copiar seleccionar reemplazar archivos si ya existen.

48

Ejecutar Basic4android y hacer clic en el menú Tools->Configure Paths.

Figura 26.- Configuración de directorios Hacer clic en el primer botón Browse y buscar JAVAC.EXE en el directorio donde se instaló, Después hacer clic en el segundo botón Browse y buscar en la carpeta Android-8 el archivo ANDROID.JAR y por ultimo hacer clic en el tercer botón Browse y buscar la carpeta Bibliotecas adicionales

Figura 27.- Ubicación de JAVAC.EXE Y ANDROID.JAR

49

Hacer clic en Tools->Run AVD manager y esperar que se ejecute el SDK MANAGER

Figura 28.- Ejecución de SDK MANAGER En la barra de menú de SDK MANAGER hacer clic en Tool->Manage AVDs.

Figura 29.- Administrar AVDs

50

Hacer clic en nuevo

Figura 30.- Crear un AVD Rellenar los siguientes campos y después dar clic en siguiente: Name: MY_ANDROID_DEVICE Target: Android 2.2 - API Level 8 Built-in: WQVGA400

Figura 31. - AVD creado

51

Hacer clic en OK

Figura 32.- Resultado del AVD creado. Hacer clic en Start y después en Launch

Figura 33.- Ejecutar el AVD creado.

52

Esperar a que cargue el AVD

Figura 34.- AVD Iniciando AVD listo para usar

Figura 35.- AVD Corriendo

53

Basic4android es un entorno de desarrollo sencillo y potente orientado a dispositivos Android, es similar al lenguaje de Visual Basic con soporte adicional para los objetos. Incluye un potente diseñador de interfaces de usuario con soporte integrado para múltiples pantallas y orientaciones. Es posible desarrollar y depurar con el emulador de Android o con un dispositivo real mediante USB conectado o a través de la red local.Basic4android tiene un amplio conjunto de librerías que facilitan el desarrollo de aplicaciones avanzadas. Esto incluye: SQL, GPS, Bluetooth, cámara, IOIO, USB, servicios, JSON, animaciones, Wi-Fi, TTS, reconocimiento de voz, gráficos, OpenGL, y más.

El Entorno de Desarrollo Integrado (IDE) Al ejecutar el IDE obtendrá un formulario similar a la siguiente imagen:

54

1.- Menú y Toolbar

1.1.- Toolbar

55

1.2.- Menú Archivo

New Open Source Save Export as Zip Page Setup Print Preview Print

Genera un nuevo proyecto. Carga un proyecto. Guarda el proyecto actual. Exporta todo el proyecto en un archivo Zip. Configuración de las páginas a imprimir Muestra una vista previa de impresión Imprime el código.

1.3.- Menu Edición

56

Cut Corta el texto seleccionado y lo copia al portapapeles. Cut Line Corta la línea en la posición del cursor. Copy Copia el texto seleccionado al portapapeles. Paste Pega el texto en el portapapeles en la posición del cursor. Undo Deshace la última operación. Redo Rehace la operación anterior. Find Activa la función buscar y reemplazar. Block Comment Establece las líneas seleccionadas como comentarios. Block Uncomment Descomenta las líneas seleccionadas. Remove all Bookmarks Elimina todos los marcadores. Remove all Breakpoints Elimina todos los puntos de interrupción Outlining Contraer código 1.4.- Menu Proyecto

Add New Module Add Existing Module Change Module Name Remove Module Hide Module Activity Properties Choose Icon Package Name Application Label

Agrega un nuevo módulo Añadir un módulo existente Cambia el nombre del módulo Quita el módulo actual Oculta el módulo actual Propiedades de la actividad, explicado abajo Elige un icono para la aplicación. Cambia el nombre del paquete. Cambia el nombre de la aplicación.

57

Application Versión Can internal storage Orientations Supported Compile & Run Include Debug Information Attach to Debbugger

Cambia la versión de la aplicación. La aplicación se instala en almacenamiento externo Orientaciones compatibles, explicado abajo. Diferentes modos de compilación. Incluir Información de depuración Conectar al depurador

Agregar un nuevo modulo Módulo de actividad Módulo de código Módulo de servicio

Propiedades de la actividad

Pantalla completa Incluir titulo

Orientaciones compatibles Ambos modos Solo retrato Solo paisaje

1.5.- Menu Herramientas

58

IDE Options B4A Bridge Clean Files Folder Clean Project Run AVD Manager Configure Paths Restart ADB Server Private Sign Key

Opciones de IDE Herramienta de depuración B4A Limpiar archivos sin utilizar Limpiar proyecto Ejecutar el administrador de AVD Configurar rutas Reiniciar el servidor ADB Clave privada para firmar apps

2.- Pestañas Hay 4 pestañas en la parte inferior derecha del IDE que mostrar la siguiente información.

2.1.- Pestaña de módulos y subrutinas Todos los módulos del proyecto y todas las subrutinas del módulo seleccionado aparecen en dos listas en el derecho del IDE.

Lista de módulos Al hacer clic en un módulo muestra su código en el área de código. Lista de subrutinas del módulo seleccionado Al hacer clic en una subrutina muestra su código en medio del área de código.

59

2.2.- Archivos Esta ventana muestra todos los archivos que se han agregado al proyecto. Estos archivos se guardan en la carpeta Files.DirAssets. Estos pueden ser cualquier tipo de archivos: diseños, imágenes, textos, etc. Hacer clic en el botón Add Files para agregar archivos al proyecto. Se accede a los archivos de esa carpeta con File.DirAssets

Al hacer clic en el botón Remove Selected elimina los archivos seleccionados de la lista de la carpeta de archivos del proyecto.

Asegurarse de tener una copia de los archivos a quitar, porque no se transfieren a la papelera de reciclaje, son definitivamente perdidos si no se tiene una copia. 2.3.- Librerías Lista de las bibliotecas disponibles que se pueden utilizar en el proyecto. Comprobar las bibliotecas que se necesitan para cada proyecto. Asegurarse de que se cuenta con la última versión de las bibliotecas.

60

La documentación de las bibliotecas puede encontrarse aquí: http://www.basic4ppc.com/android/documentation.html http://www.basic4ppc.com/android/wiki/index.php/Libraries

61

3.- El diseñador El diseñador permite generar diseños con el emulador o un dispositivo real.

3.1.- El menú del diseñador

62

3.1.1- El menú archivo

New Open Save Save As

Se abre un nuevo diseño de vacío. Abre un diseño existente Guarda el diseño actual. Guarda el diseño actual con un nuevo nombre.

3.1.2- El menú agregar View Este menú le permite seleccionar el View que desea agregar en el diseño actual en el dispositivo o el emulador.

Button CheckBox EditText ImageView Label ListView Panel ProgressBar RadioButton ScrollView SeekBar Spinner TabHost ToggleButton WebView

agrega un botón agrega una casilla de verificación agrega unacajadetexto agrega unacaja de imagen agrega una etiqueta agrega un control tipo lista agrega un contenedor agrega una barra de progreso agrega un radio botón agrega un vista scroll agrega una barra deslizable agrega un combo agrega un tabulador agrega un botón toggle agrega una vista Web

63

3.1.3- El menú herramientas

Generate Members Generar miembros Bring to Front Trae el View seleccionado al frente Send To Back Trae el View seleccionado al frente Duplicate Selected Views Duplica el View seleccionado Remove Selected Views Elimina el View seleccionado Change Grid Cambia el tamaño de la cuadrícula Connect Conecta al dispositivo o el emulador Disconnect Desconecta del dispositivo o emulador

3.2- Lista de propiedades Una lista de las propiedades del View seleccionado organizados en grupos. Todas las propiedades pueden modificarse directamente en la lista. Todas las propiedades en el grupo principal y algunos de las propiedades de los otros grupos son comunes a todos los tipos de Views.

64

3.2- Variantes de diseño Las de diseño diferente pueden gestionarse en un mismo archivo de diseño para tener mayor compatibilidad con distintos tamaños de pantalla y configuraciones.

En otro capítulo se explican los conceptos de pantalla tales como los pixeles, la resolución, densidad, etc. y la metodología para hacer aplicaciones con distintos tamaños de pantalla

65

Como primer ejemplo se desarrollara la aplicación más sencilla que se puede hacer para ilustrar el uso de Basic4android y el proceso de construcción de la aplicación, se utilizara el emulador con el AVD creado en la sección anterior y como segundo ejemplo se construirá una aplicación básica pero con interfaz de usuario para utilizar el designer, se recomienda crear una carpeta para las aplicaciones que se desarrollaran a lo largo de la guía. Las aplicaciones listas para instalar y probar se encuentran en la carpeta APK del CD. El código fuente y el proyecto de las aplicaciones se encuentran en la carpeta APLICACIONES ANDROID del CD Antes de instalar cualquier aplicación externa a la tienda en línea de Google es necesario activar la opción para instalar software de terceros en el dispositivo, marcando la opción del menú Ajustes>Aplicaciones-> Orígenes desconocidos

HOLA MUNDO Descripción de la aplicación: Muestra un cuadro de texto al iniciar la aplicación Interfaz de usuario: Sin interfaz de usuario Hardware: Dispositivo Android

1.

Ejecutar Basic4Android

2. Guardar el proyecto con el nombre HOLA MUNDO desde el menú File->Save 3. Como el objetivo es mostrar un mensaje al iniciar la aplicación se usara el evento Activity_Create para dar la instrucción. Existen varios tipos de mensajes en Android el que se usara en este ejemplo se conoce como MSGBOX (cuadro de mensaje) y necesita dos parámetros uno es el contenido del mensaje y el otro el título. El comando deberá quedar como se muestra a continuación:

66

Msgbox("contenido","titulo") El evento Activity_Create quedara de la siguiente manera (los textos en color verde son comentarios):

4. El siguiente paso es configurar el proyecto a través del menú Project con las siguientes configuraciones: Include Debug Information: Desmarcado Attach To Debugger: Desmarcado Todo esto con el fin de eliminar la depuración desde Basic4Android y ejecutar normalmente la aplicación. Para marcar o desmarcar basta con hacer clic en la opción. Por el momento las demás opciones se quedan con la configuración por default. 5. Dar clic en la barra de herramientas al icono RUN

Aparecerá una ventana pidiendo nombre del paquete, esto puede hacerse también desde el menú Project. El nombre del paquete deberá quedar con el formato algo.algo en este ejemplo quedara como ejercicio1.android

En la siguiente ventana se debe introducir el Label de la aplicación también se puede hacer desde Project. El Label de la aplicación es aquel que aparece junto al icono en esta ocasión será Ejercicio 1

67

6. Esperar a que termine el proceso de compilación y que la aplicación inicie en el emulador

El resultado será el siguiente

Reto: Explorar el Ejercicio 2 llamado TOASTMESSAGE que se encuentra en la carpeta APLICACIONES ANDROID del CD

68

LOAD LAYOUT Descripción de la aplicación: Carga un Layout previamente diseñado Interfaz de usuario: Todos los Views Hardware: Dispositivo Android

1. Ejecutar Basic4Android 2. Guardar el proyecto con el nombre LOAD LAYOUT desde el menú File->Save 3. Dar clic en el menú Designer 4. Conectarse al Emulador haciendo clic en el menú del Desginer Tools->Connect

El estado de la conexión se muestra debajo del menú

Es necesario que el emulador esté en funcionamiento para que pueda conectarse con el Designer cuando la conexión se haya establecido el emulador quedara como se muestra en la siguiente imagen

69

5. Diseñar el Layout: Ponerle el título Ejercicio 4 a la actividad, a través del menú propiedades del Designer, la parte superior del menú indica el objeto que se está editando y debajo aparecen las propiedades. Se puede explorar otras opciones de la actividad como el fondo con la propiedad Drawable y por ejemplo poner de fondo un gradiente.

Agregar un Button al diseño haciendo clic en el menú del Desginer Add View->Button el Button aparecerá en el emulador

Cuando los cuadros rojos aparecen alrededor de un View significa que esta seleccionado y se puede arrastrar y cambiar su tamaño. Continuar con el diseño agregando los demás Views restantes y acomodarlos para que todos sean visibles en la pantalla. 6. Guardar el Layout con el nombre mi_layout 7. Agregar al código la instrucción para cargar el Layout. La manera de cargar el diseño es por medio del comando Actitvity.LoadLayout y solo se necesita como parámetro el nombre del Layout. El momento para cargar el Layout es cuando la aplicación inicia esto es en el evento Activity_Create. El comando deberá quedar como se muestra a continuación:

70

Activity.Loadlayout("nombre_del_layout") El evento Activity_Create quedara de la siguiente manera (los textos en color verde son comentarios):

Al escribir las instrucciones como Activity justo después de poner el punto el autocompletado permite ver las funciones, parámetros, propiedades, etc. 8. Configurar la aplicación repitiendo el paso 4 del primer ejemplo con los siguientes parámetros: Include Debug Information: Desmarcar (en caso de estarlo) Attach To Debugger: Desmarcar (en caso de estarlo) Can Install To External Storage: Marcar La única diferencia con el ejemplo anterior es que la aplicación se podrá instalar en la memoria SD 9. Repetir los pasos 5 y 6 del ejemplo anterior e ingresar lo siguiente: Package Name: ejercicio4.android Label: Ejercicio 4 El resultado será el siguiente

71

La aplicación no hace mucho ya que el objetivo fue diseñar y cargar un Layout pero se puede interactuar con los Views. Otra forma de diseñar y ejecutar aplicaciones es desde el dispositivo real para ello es necesario activar la depuración en el dispositivo y tener instalados los drivers. El primer paso es instalar el software proporcionado en el CD de su dispositivo Android o bien descargar el software desde la página del fabricante, con esto se instalaran los drivers, Después en el menú del dispositivo marcar la opción de depuración a través de Ajustes->Aplicaciones->Desarrollo->Depuración USB. Luego conectar el dispositivo y esperar a que esté listo para usar. Al momento de tratar de instalarse la aplicación o de conectar con el Designer se hará con el emulador o en el dispositivo dependiendo de cuál esté conectado en caso de estar presentes los dos aparecerá una ventana para seleccionar con cual trabajar.

Reto: Diseñar un Layout en orientación Landscape con el dispositivo real

72

ACTIVITY MENU Descripción de la aplicación: Muestra un mensaje según la opción seleccionada Interfaz de usuario: Menú ítem (solo disponible desde código) Hardware: Dispositivo Android A partir de este punto se omitirán los pasos básicos tales como ejecutar el IDE, guardar el proyecto, etc. Se usara siempre la opción de instalar la aplicación en el almacenamiento externo, también se omitirán los comentarios de código en las imágenes para tener mayor espacio ya que se proporciona todo el código fuente con comentarios. Todo lo anterior con el fin de enfocarse en los nuevos conceptos. Este ejemplo utiliza un tipo de control que solo se puede crear desde código conocido como menú ítem y un tipo de mensaje utilizado en el ejercicio 2 a modo de reto, llamado Toastmessage, el objetivo es entender el flujo del programa. Nombre del Proyecto: ACTIVITY MENU Package Name: ejercicio3.android Application Label: Ejercicio 3 Los Ítems de menú aparecen cuando el usuario presiona la tecla menú del dispositivo. Para crear un ítem se utiliza el comando Activity.AddMenuItem que necesita dos parámetros uno es el texto del ítem y el otro es el evento o la subrutina asociada a el boton, recordar que los botones tiene un evento principal que es el clic. La sintaxis del comando es la siguiente: Activity.AddMenuItem("titulo","evento") Es un comando de inicialización o construcción por lo tanto debe declararse en el evento Activity_Create

73

Se ha construido dos ítems uno con el título opción 1 y el otro con el titulo opción 2. El parámetro más importante es el evento puede ser cualquier texto pero se debe usar una metodología para no equivocarse al momento de tocar el ítem opción 1 el flujo del programa buscara la subrutina evento_opcion_1, pasara lo mismo con el Ítem opción 2. Por lo tanto además de definir un evento habrá que construir la subrutina que pueden agregarse al final del código como se muestra a continuación:

Cada subrutina comienza por Sub seguido del nombre del evento que siempre debe ser el mismo que se declara como cuando construye un ítem seguido de un guion y el evento fundamental. Por ejemplo se definió evento_opcion_1 y el evento fundamental es el clic en el caso del Ítem opción 1, Por lo tanto queda como evento_opcion_1_clic. Cada subrutina termina con End Sub y es en este bloque donde se pondrán todas las acciones a realizar al tocar el Ítem. En este caso para cada Ítem aparecerá un Mensaje tipo Toast al tocarlo Al correr la aplicación y presionar el botón menú del dispositivo aparecerán los ítems y al tocar un ítem aparecerá el mensaje Toast

74

Un mensaje Toast es aquel que se desvanece después de un tiempo Reto: Aumentar los ítems y los mensajes a 4

BUTTON Descripción de la aplicación: Muestra un mensaje al tocar el botón Interfaz de usuario: 1 Button Hardware: Dispositivo Android En este ejemplo se hace uso del primer View para interactuar con la aplicación. Al tocar el botón se mostrara un cuadro de mensaje (MSGBOX). Diseñar el Layout agregando un Button y guardarlo con el nombre layout_ejercicio_5. El propósito de este ejemplo es vincular los Views con el código Nombre del Proyecto: BUTTON Package Name: ejercicio5.android Application Label: Ejercicio 5 El primer paso para vincular el Boton con el código es declararlo, pero al ser un View esto se puede hacer desde el designer por medio del menú Tools->Generate Members aparecerá una ventana en la que se muestran los Views utilizados en el diseño y también la actividad

Al expandir los elementos aparecerán sus eventos

75

Se deben marcar los Views y eventos que se desean vincular al diseño en este caso se marcara el Button1 y su evento clic y después dar clic al botón Generate members.

Automáticamente el objeto se declara en Sub Globals

Y también la subrutina correspondiente al evento del objeto, el comando Msgbox es agregado por el usuario

Al correr la aplicación y tocar el Button1 uno aparecerá el Msgbox

76

Reto: Usar el Button1 con otro evento

LABEL Descripción de la aplicación: Cambia el Texto de un Label al tocar un Button Interfaz de usuario: 1 Button, 1 Label Hardware: Dispositivo Android A partir de este punto se omitirá también el proceso de diseño del Layout, generar los miembros y cargar el Layout, en la parte superior de cada ejemplo se especifica los Views necesarios para la interfaz de usuario, se proporciona además los Layout de cada ejercicio están en la carpeta APLICACIONES ANDROID->FILES del CD, también se especificara las propiedades y eventos necesario para cada View. En este ejemplo se hace de un View visto anteriormente y un view de texto llamado Label. Al tocar el boton el texto del Label cambiara. Nombre del Proyecto: LABEL Package Name: ejercicio6.android Application Label: Ejercicio 6 El Layout deberá quedar como se muestra a continuación:

77

El código necesario para cambiar el texto del Label es a través de la propiedad Text y su sintaxis es la siguiente: Label1.Text="Cualquier_Texto" El evento Click del Button1 deberá quedar de la siguiente manera

El resultado de la aplicación al tocar el Button1 será el siguiente

Reto: Agregar un botón para restablecer el texto del Label

78

SEEKBAR Descripción de la aplicación: Muestra la posición de un Seekbar en un Label Interfaz de usuario: 1 Seekbar, 1 Label Hardware: Dispositivo Android Nombre del Proyecto: SEEKBAR Package Name: ejercicio7.android Application Label: Ejercicio 7 El Layout deberá quedar como se muestra a continuación:

El Seekbar es un tipo de View numérico, dependiendo la posición en que se encuentre será su valor, este valor se puede leer con la propiedad Value. El evento será ValueChanged que es cuando cambia su posición. Los valores que toma son enteros y por medio de la propiedad Max se puede configurar el máximo valor que puede tomar. El código necesario para leer la posición es el siguiente: Variable=SeekBar1.Value Donde Variable es una variable declarada necesaria para guardar el valor, pero el lenguaje Basic permite asignar directamente un valor entero a un Label. El código del evento del Seekbar deberá quedar de la siguiente forma:

79

El resultado de la aplicación al deslizar el Seekbar será el siguiente

Reto: Avisar al usuario cuando se ha llegado al mínimo y al máximo valor

PROGRESSBAR Descripción de la aplicación: Muestra la posición de un Seekbar en un Label y en un ProgressBar Interfaz de usuario: 1 Seekbar, 1 Label, 1 ProgressBar Hardware: Dispositivo Android Nombre del Proyecto: ProgressBar Package Name: ejercicio8.android Application Label: Ejercicio 8 El Layout deberá quedar como se muestra a continuación:

80

El ProgressBar tiene el funcionamiento contrario al SeekBar se puede configurar la posición o progreso a través de la propiedad Progress, siendo 100 el valor máximo que puede tomar, y además no tiene eventos. El código necesario para escribir la posición es el siguiente: ProgressBar1.Progress=algún valor entero Donde algún valor entero puede ser una constante o una variable por ejemplo al leer la posición de un Seekbar se obtiene un entero por lo cual se puede asignar directamente. El código del evento del Seekbar deberá quedar de la siguiente forma:

El resultado de la aplicación al deslizar el Seekbar será el siguiente

Reto: Ajustar lo necesario para aumentar el rango a 1024

RADIOBUTTON Descripción de la aplicación: Cambia el color del texto de un Label según la opción seleccionada Interfaz de usuario: 3 RadioButton, 1 Label Hardware: Dispositivo Android

81

Nombre del Proyecto: RADIOBUTTON Package Name: ejercicio9.android Application Label: Ejercicio 9 El Layout deberá quedar como se muestra a continuación:

El RadioButton es un control de selección y su estado puede saberse a través de la propiedad Checked, siendo True o False los dos valores que puede tomar, el evento utilizado es el CheckedChange que es cuando cambia de estado, cuando están agrupados solo se puede seleccionar un RadioButton. El código necesario para leer su estado es el siguiente: Variable=RadioButton1.Checked Donde Variable es de tipo booleano, sin embargo la manera general de usar estos controles es a través de bloques IF THEN. Un color se puede establecer de una manera fácil por medio de la función Colors, el autocompletado mostrara las diferentes opciones disponibles. Para este ejemplo se utilizan los colores rojo, verde y azul Cada RadioButton establece un color para el texto del Label por lo tanto se pondrá una instrucción en cada evento correspondiente, el código deberá quedar como se muestra a continuación.

82

El resultado de la aplicación al seleccionar cada RadioButton será el siguiente:

Reto: agregar otro grupo de RadioButton para controlar el color del texto de otro Label

83

CHECKBOX Descripción de la aplicación: Controla el estilo de un Label según las opciones marcadas Interfaz de usuario: 3 CheckBox, 1 Label Hardware: Dispositivo Android Nombre del Proyecto: CHECKBOX Package Name: ejercicio10.android Application Label: Ejercicio 10

El Layout deberá quedar como se muestra a continuación:

El CheckBox es un control de selección igual al RadioButton, con la diferencia de que se puede seleccionar más de uno. El código necesario para leer su estado es el siguiente: Variable=CheckBox1.Checked Donde Variable es de tipo booleano, sin embargo al igual que un RadioButton la manera general de usar estos controles es a través de bloques IF THEN. Este ejemplo es parecido al anterior con la diferencia que se controla el estilo de texto: negrita, minúscula y resaltado, el código deberá quedar como se muestra a continuación.

84

El resultado de la aplicación al combinar las opciones será el siguiente:

Reto: Sustituir los CheckBox por ToggleButton

85

En el bloque anterior se desarrollaron aplicaciones básicas utilizando los principales Views para familiarizarse con el entorno Basic4Android, a continuación se realizaran aplicaciones que incluyan el uso de librerías para explorar las funciones características de Android como los sensores, las notificaciones, el reconocimiento de voz, etc. Al igual que en el capítulo anterior las aplicaciones listas para instalar y probar se encuentran en la carpeta APK del CD, también el código fuente y el proyecto de las aplicaciones se encuentran en la carpeta APLICACIONES ANDROID del CD

ANIMATION Descripción de la aplicación: Anima un objeto con la librería ANIMATION Interfaz de usuario: 2 Button, 6 RadioButton Hardware: Dispositivo Android Nombre del Proyecto: ANIMATION Package Name: ejercicio11.android Application Label: Ejercicio 11

El Layout deberá quedar como se muestra a continuación:

86

La librería Animation está orientada a aplicar animaciones a los Views, para utilizar cualquier librería es necesario incluirla en el proyecto marcando la correspondiente de las que aparecen disponibles en la pestaña Libs del lado inferior derecho del IDE, la librería Core siempre aparecerá marcada ya que contiene los comandos básicos para cualquier aplicación.

La librería ANIMATION ofrece 6 tipos diferentes de animaciones, para construir una aplicación primero se debe declarar el objeto como tipo Animation en este caso lo que se pretende es explorar las 6 opciones por lo tanto se debe declarar esa cantidad de objetos, también se necesita

87

una variable que se declara como x que más adelante se explica, el código correspondiente a la declaración debe quedar de la siguiente manera:

Cualquier variable que se declara en Basic se declara de la siguiente forma: Dim nombre_de_la_variable As tipo_de_variable

En la parte Sub Globals del código aparecen también los objetos declarados ya que esto lo hace automáticamente el designer al generar miembros. El siguiente paso es construir cada una de las animaciones, ya que esto es una creación o inicialización el código deberá ir en la parte Activity_Create como se muestra a continuación:

88

Para una animación se debe definir 4 cosas: el tipo de animación, la duración de la animación, las veces que se repetirá y el modo de repetición. Las tres últimas son iguales para todos los tipos y se establecen por medio de las propiedades Duration, RepeatCount y RepeatMode respectivamente. El desarrollador no debe olvidar para acceder a las propiedades primero se escribe el nombre del objeto seguido de punto y el autocompletado muestra todas sus propiedades, constantes y funciones. La duración se expresa en milisegundos, la cantidad de repeticiones en un entero y el modo de repetición por medio de una constante del propio objeto que puede ser REPEAT_REVERSE O REPEAT_RESTART, lo que significa que la animación hará reversa o reiniciara

89

para repetir. Un punto muy importarte para tener una idea de la sintaxis de los comandos es identificar qué tipo de propiedad es, en un objeto pueden aparecer los siguientes símbolos:

El primero (mano) indica que la propiedad necesita un valor proporcionado a través del operador de asignación =, Como es el caso de Duration. El segundo símbolo (cuadro purpura) indica que la propiedad es más compleja que necesita ciertos parámetros como es el caso de LoadLayout() , casi siempre de esa forma con los paréntesis. El último icono (cuadro azul) significa que es una constante y se debe usar como en el caso de Repeat_Reverse. El IDE muestra también ejemplos de sintaxis como en el caso de los tipos de animación. Para ilustrar cada tipo de animación se utilizan 6 RadioButton y un boton para ejecutar la acción de iniciar la animación. Por lo tanto se debe checar el estado de cada RadioButton y de alguna forma hacerle saber al boton cual esta seleccionado. Esto se hace por medio de la variable X como se muestra a continuación:

90

El Button2 será el encargado de iniciar las animaciones por medio de la propiedad Start, cabe aclarar que el Button1 solo sirve para que a través de él se muestre la animación de un View, el código quedara de la siguiente manera:

El resultado de la aplicación (animaciones alpha, rotate y scale) será el siguiente

Reto: Controlar las coordenadas de la animación translate por medio del evento Touch de la actividad

91

TTS Descripción de la aplicación: Convierte de texto a voz Interfaz de usuario: Sin interfaz de usuario Hardware: Dispositivo Android Nombre del Proyecto: TTS Package Name: ejercicio12.android Application Label: Ejercicio 12 La librería TTS (Text To Speech) es una función de Android que permite convertir texto en voz implementado desde la versión 2.2 de Android (froyo). Para utilizar esta característica es necesario tener instalado en el dispositivo los datos de voz, esto se puede verificar en el menú Ajustes>Entrada y Salida de Voz->Ajustes de síntesis de Voz->Escuchar un ejemplo, si no se logra escuchar el ejemplo será necesario instalar los datos de voz a través de Ajustes->Entrada y Salida de Voz->Ajustes de síntesis de Voz->Instalador Datos de Voz, Este proceso conduce a la tienda en línea de Google para descargar los datos. El primer paso es marcar la librería TTS, después declarar el objeto sintetizador_de_voz como tipo TTS como se muestra a continuación:

El siguiente paso es inicializar el objeto a través de la propiedad Initialize y requiere solo de un parámetro en este caso un evento que se nombrara como Event_sintetizador el código debe quedar de la siguiente manera:

92

El evento fundamental del TTS es cuando ha terminado de inicializarse llamado Ready y por medio de su variable local Success se puede saber si la operación fue exitosa o surgió algún problema, para sintetizar un texto se utiliza la propiedad Speak y se ingresan dos parámetros uno es el texto a sintetizar y el otro especifica si se puede interrumpir la síntesis o terminar (esto en caso de que en el momento de estar “hablando” se presente otra instrucción de síntesis). El código queda de la siguiente manera:

El resultado de la aplicación será un mensaje de voz al iniciar Reto: Implementar las propiedades Pitch y SpeechRate

VOICE RECOGNITION Descripción de la aplicación: Convierte de voz a texto Interfaz de usuario: 1 Button Hardware: Dispositivo Android Nombre del Proyecto: VOICE RECOGNITION Package Name: ejercicio13.android Application Label: Ejercicio 13 La librería VOICE RECOGNITION (reconocimiento de voz) es una función de Android que permite convertir texto en voz implementado desde la versión 2.2 de Android (froyo), No todos los fabricantes implementan esta función por lo tanto habrá que averiguar si el dispositivo lo soporta, una forma es verificar si está instalada la aplicación de búsqueda por voz. El principio de funcionamiento es el siguiente: el usuario indica que introducirá un comando de voz, la aplicación indica el momento para hacerlo, graba el mensaje, la envía a un servidor, y el servidor regresa las coincidencias. Este proceso es muy rápido pero requiere conexión a internet.

93

En este caso la librería a incluir es la llamada Phone ya que Basic4android la considera una función telefónica se necesita declarar un objeto tipo VoiceRecognition pero requiere que sea en el área Sub Process_Globals, el nombre será VR, el código deberá quedar de la siguiente manera:

El siguiente paso es inicializar el objeto con el nombre de un evento, como se mencionó anteriormente es posible saber si la función de reconocimiento de voz es soportada a través de la propiedad IsSupported, la propiedad Prompt establece el texto para indicar que es momento de hablar. El código correspondiente se muestra a continuación:

El reconocimiento de voz responde a un evento llamado Result que es cuando se ha completado el proceso, a través de Success se puede saber si se realizó con éxito o hubo algún problema, y los resultados de la conversión se obtienen de la variable Texts, el código es el siguiente:

94

Con lo cual se muestra a través de un mensaje Toast el primer resultado obtenido, se toma el primer elemento de la lista con Get(). El último paso es iniciar el reconocimiento de voz con el evento clic del Button1 esto se logra con la propiedad Listen del objeto VR como se muestra a continuación:

Para correr la aplicación es necesario desde el dispositivo Reto: Mostrar todos los resultados de la lista TIMER Descripción de la aplicación: Muestra un contador Interfaz de usuario: 2 Button, 1 Label Hardware: Dispositivo Android Nombre del Proyecto: TIMER Package Name: ejercicio14.android Application Label: Ejercicio 14 El Timer es un objeto muy importante en el desarrollo de aplicaciones, Junto con las interrupciones forman la base para el multiproceso. El Timer está implementado en la librería Core por lo tanto no es necesario marcar ninguna extra. El Layout deberá quedar como se muestra a continuación:

95

Se necesita declarar un objeto tipo Timer en el área Sub Globals con el nombre Temporizador, también una variable tipo Byte con el nombre X, el código deberá quedar de la siguiente manera:

El siguiente paso es inicializar el objeto con el nombre de un evento y una cantidad entera que expresa el tiempo en que se generara una interrupción en milisegundos. El código correspondiente se muestra a continuación:

El Timer responde a un evento llamado Tick que significa una cuenta o que ha pasado el tiempo especificado para interrumpir, en esta subrutina se incrementa la variable X para después mostrar un contador en el Label1, el código es el siguiente:

96

Se utilizan 2 Button uno para iniciar y el otro para detener las interrupciones del Timer a través de su propiedad Enabled, el código es el siguiente:

El resultado será un contador en pantalla. Reto: Utilizar un SeekBar para configurar el tiempo de cada cuenta. PROXIMITY SENSOR Descripción de la aplicación: Detecta la proximidad de un objeto Interfaz de usuario: 1 ProgressBar, 1 Label Hardware: Dispositivo Android, algún objeto Nombre del Proyecto: PROXIMITY SENSOR Package Name: ejercicio15.android Application Label: Ejercicio 15 El Sensor de proximidad parte del hardware del teléfono utilizado para funciones telefónicas, su rango de alcance varía según el dispositivo, pero no mide distancia si no que indica si hay algo cercano o no. Para utilizarlo es necesario incluir la librería Phone. El Layout deberá quedar como se muestra a continuación:

97

Se necesita declarar un objeto tipo PhoneSensors en el área Sub Globals con el nombre Proximidad, el código deberá quedar de la siguiente manera:

El siguiente paso es inicializar el objeto con el tipo de sensor, esto se hace a través de una constante del propio objeto llamado TYPE_PROXIMITY. El código correspondiente se muestra a continuación:

Para hacer que el sensor comience a funcionar automáticamente se utiliza el evento Activity_Resume para que de esa forma vuelva a funcionar si la aplicación regresa del segundo plano, esto se logra a través de StartListening y se especifica el nombre del evento, el evento Acitivity_Pause se utiliza para liberar el sensor con StopListening y pueda ser utilizado por otra aplicación:

98

El sensor de proximidad responde a un evento llamado SensorChanged que es cuando un objeto se aproxima o aleja, en esta subrutina se muestra en un Label el valor que entrega el sensor a través de la variable Values() y después se compara para mostrar una representación en un ProgressBar, el código es el siguiente:

La aplicación necesita probarse en el dispositivo real ya que en el emulador no se cuenta con un sensor de proximidad. Reto: Hacer que el dispositivo vibre al acercarse un objeto.

MAGNETOMETER Descripción de la aplicación: Mide la intensidad de campo magnético Interfaz de usuario: 1 ProgressBar, 1 Label Hardware: Dispositivo Android, algún objeto metálico o inductivo Nombre del Proyecto: MAGNETOMETER Package Name: ejercicio16.android Application Label: Ejercicio 16 El Sensor magnético es parte del hardware del teléfono utilizado como brújula electrónica, orientación, detector de metales, etc., la gran mayoría de los dispositivos Android implementan este sensor, mide la intensidad de campo magnético en los tres ejes X,Y,Z, la librería para usar este sensor es Phone como en el ejemplo anterior. El Layout deberá quedar como se muestra a continuación:

99

Se necesita declarar un objeto tipo PhoneSensors en el área Sub Globals con el nombre Magnetometer, y también 3 variables tipo Float para guardar las lecturas del sensor, el código deberá quedar de la siguiente manera:

El siguiente paso es inicializar el objeto con el tipo de sensor, esto se hace a través de una constante del propio objeto llamado TYPE_MAGNETIC_FIELD. El código correspondiente se muestra a continuación:

100

Para hacer que el sensor comience a funcionar automáticamente se utiliza el evento Activity_Resume para que de esa forma vuelva a funcionar si la aplicación regresa del segundo plano, esto se logra a través de StartListening y se especifica el nombre del evento, el evento Acitivity_Pause se utiliza para liberar el sensor con StopListening y pueda ser utilizado por otra aplicación:

El sensor magnético responde a un evento llamado SensorChanged que es cuando cambia el valor del campo magnético en cualquiera de los ejes, en esta subrutina los valores que entrega el sensor se guardar en sus respectivas variables, a una cuarta variable se le asigna el total del valor del campo magnético haciendo una operación matemática (raíz cuadrada), se muestra el resultado en un Label y en un ProgressBar, el código es el siguiente:

La aplicación necesita probarse en el dispositivo real ya que en el emulador no se cuenta con un sensor magnético. Reto: Hacer una aplicación que detecte metal.

101

ADVANCED CAMERA Descripción de la aplicación: Captura una foto Interfaz de usuario: 1 Panel, 1 ImageView, 1 Button Hardware: Dispositivo Android Nombre del Proyecto: ADVANCED CAMERA Package Name: ejercicio17.android Application Label: Ejercicio 17 La cámara es un dispositivo muy importante en robótica con ella se pueden hacer aplicaciones por ejemplo para robots exploradores a un bajo costo y fácil implementación, para usarla en basic4android se utilizara el propósito básico que es capturar imágenes y guardarlas, la librería para usar el hardware se llama ADVANCED CAMARA, esta librería de terceros tiene más funciones que la librería original de Basic4android El Layout deberá quedar como se muestra a continuación:

Se necesita declarar un objeto tipo AdvancedCamara en el área Sub Globals con el nombre Cámara, el código deberá quedar de la siguiente manera:

102

El siguiente paso es inicializar el objeto especificando un panel y el nombre de un evento, el parámetro más importante es el medio que se usa para mostrar el preview de la cámara y siempre será un panel. El código correspondiente se muestra a continuación:

Para hacer que el sensor comience a funcionar automáticamente se utiliza el evento Ready de la cámara y a través de Success se verifica si la inicialización fue exitosa, se establece la orientación de la cámara en retrato por medio de la propiedad OriPortrait y por último se pone en funcionamiento a través de StarPreview. El evento Acitivity_Pause se utiliza para liberar el sensor con Release para que pueda ser utilizado por otra aplicación, pero antes se detiene el preview con StopPreview, el código queda de la siguiente manera:

Para tomar una fotografía se construye una subrutina debe llamarse siempre PictureTaken ya que actuara como un evento de la cámara que básicamente lo que hace es abrir un medio para escribir en memoria un archivo, por lo pronto el lector no le debe prestar mucha importancia a entender las instrucciones con respecto a la variable Out, después de la captura la imagen se muestra en un ImageView, el código es el siguiente:

103

En Android existen 5 directorios para trabajar con archivos: File.DirAssets: Se trata de archivos distribuidos con la aplicación en el empaquetado APK, para incluir archivos con la aplicación se utiliza la pestaña Files y con el boton Add Files como se muestra en la imagen

File.DirInternal / File.DirInternalCache: Estas dos carpetas se almacenan en la memoria principal y son privadas para la aplicación, ninguna otra aplicación puede accesar a estos archivos.

File.DirRootExternal: el directorio raíz del almacenamiento externo (memoria SD) File.DirDefaultExternal: La carpeta predeterminada para una aplicación en almacenamiento externo. Otras aplicaciones pueden acceder a la carpeta mediante la ruta: [dispositivo externo] / Android / data / [nombre del paquete] / files / En el ejemplo se usa el directorio File.DirRootExternal para guardar la imagen. Para mostrar la captura se utiliza el ImageView1 y por medio de la propiedad Bitmap se carga la imagen con ayuda de la función LoadBitmap, esta función requiere dos parámetros uno es el directorio y el otro el nombre completo del archivo.

104

Por ultimo con un Button se llama a la subrutina para tomar capturar la fotografía con TakePicture como se muestra en el código:

Al correr la aplicación con el emulador el resultado es el siguiente:

Reto: Agregar la función de tomar foto con cuenta regresiva.

ABZXING Descripción de la aplicación: Leer códigos de barra Interfaz de usuario: 1 Button Hardware: Dispositivo Android, código de barras o QR Nombre del Proyecto: ADVANCED CAMERA

105

Package Name: ejercicio18.android Application Label: Ejercicio 18 La función de tomar fotos con la cámara no es suficiente para implementarse en proyectos de robótica, pero reconocer objetos requiere también de conocimientos más avanzados, la librería ABZXING proporciona la función de escanear códigos de barras de una manera sencilla a través del enlace con la aplicación BarcodeScanner, se necesita tener instalada esta aplicación que se proporciona en la carpeta APK del CD e incluir la librería ABZXING en el proyecto El Layout deberá quedar como se muestra a continuación:

Se necesita declarar un objeto tipo ABZXING en el área Sub Globals con el nombre Escáner, el código deberá quedar de la siguiente manera:

El comienzo del escaneo es controlado por el Button1 con la propiedad ABGetBarCode y se especifica el evento y el tipo de código a leer, en este caso códigos de barras de productos, el código es el siguiente:

106

El ABZXING responde al evento BarCodeFound que es cuando ha terminado de escanear, y el código decodificado se obtiene a través de la variable Barcode y se muestra con un cuadro de dialogo (MSGBOX), el código es el siguiente:

Es necesario correr la aplicación con un dispositivo real. Reto: Modificar la aplicación para escanear códigos QR.

ACELEROMETER Descripción de la aplicación: Mide la aceleración en los ejes X, Y, Z Interfaz de usuario: 3 Label Hardware: Dispositivo Android Nombre del Proyecto: ACELEROMETER Package Name: ejercicio19.android Application Label: Ejercicio 19 El acelerómetro es un sensor que está en todos los dispositivos Android y provee una mayor experiencia multimedia en las aplicaciones, entrega el valor de la aceleración en los tres ejes X, Y, Z, la librería para usar este sensor es Phone como en el ejemplo anterior. El Layout deberá quedar como se muestra a continuación:

107

Se necesita declarar un objeto tipo PhoneAccelerometer en el área Sub Globals con el nombre Acelerómetro, el código deberá quedar de la siguiente manera:

Para hacer que el sensor comience a funcionar automáticamente se utiliza el evento Activity_Resume para que de esa forma vuelva a funcionar si la aplicación regresa del segundo plano, esto se logra a través de StartListening y se especifica el nombre del evento, el evento Acitivity_Pause se utiliza para liberar el sensor con StopListening y pueda ser utilizado por otra aplicación:

108

El acelerómetro responde a un evento llamado AccelerometerChanged que es cuando cambia el valor de la aceleración en cualquiera de los ejes, en esta subrutina los valores que entrega el sensor se muestran en un Label para cada una de las variables, el operador & concatena el texto fijo y el valor de la variable, el código queda de la siguiente forma:

La aplicación necesita probarse en el dispositivo real ya que en el emulador no se cuenta con un acelerómetro. Reto: Detectar inclinación los ejes X, Y (usar los valores 4 y -4 para comparar).

TABHOST Descripción de la aplicación: Carga 3 Layout utilizando un View TABHOST Interfaz de usuario: TabHost Hardware: Dispositivo Android Nombre del Proyecto: ACELEROMETER Package Name: ejercicio20.android Application Label: Ejercicio 20

El TabHost es un view útil para cuando la interfaz de usuario no alcanza en la pantalla, para esto se requiere un Layout por cada pestaña del View, No se necesita ninguna librería esta ya que esta implementado en Core Primero se necesita diseñar un layout con el control TabHost, el diseño debe como se muestra a continuación

109

Después es necesario crear 3 Layout adicionales ya que en el ejemplo se usara 3 pestañas, es importante que los Views tengan diferente nombre en cada layout, después de crear los layout deberán agregarse por medio de la pestaña Files de Basic4android, Los layout se muestran a continuación:

Y los layout deberán aparecer agregados al proyecto como se muestra en la siguiente imagen:

110

Si al momento de abrir el código fuente el programa indica que no se encuentra algún archivo como por ejemplo un layout, se deberá ubicar el archivo por este medio. Esto sucede cuando hay un cambio de lugar de la carpeta donde se guardó el código, todos los layout utilizados en esta guía se ubican en la carpeta APLICACIONES ANDROID->FILES del CD. La construcción del TabHost se lleva a cabo en el evento Activity_Create, para ello se va añadiendo cada pestaña por medio de AddTab y se define el titulo y el layout, el código queda de la siguiente manera:

El resultado es el siguiente:

111

Reto: Integrar la aplicación 3 aplicaciones de las anteriores utilizando un TabHost

NOTIFICATION Descripción de la aplicación: Muestra una notificación en la barra de estado al iniciar la aplicación Interfaz de usuario: Sin interfaz de usuario Hardware: Dispositivo Android Nombre del Proyecto: NOTIFICATION Package Name: ejercicio21.android Application Label: Ejercicio21

Las notificaciones en la barra de estado son una característica muy peculiar de Android, por este medio un proceso notifica al usuario al recibir un nuevo correo, mensaje, programa en ejecución, etc. También establecen la interacción del usuario con los servicios, esta función esta implementada en el Core así que no es necesario alguna librería extra. Lo primero es declarar un Objeto tipo Notificatión con el nombre Notificación Después se construye la notificación en el evento Activity_Create, se inicializa solo con Initialize, después se indica el icono que aparecerá en la barra de notificaciones en este caso al poner “icon”se usa el icono de la aplicación (se puede poner otro icono con LoadBitmap), después con SetInfo se proporciona la información de la notificación especificando el título, el contenido y a qué actividad llamar cuando se toque la notificación en este caso al poner solo los símbolos “” indica que ira a la actividad Main , por últimos se despliega la notificación con Notify() (el número 1 se refiere a se afecta a la primera notificación) , el código queda de la siguiente manera:

112

Al correr la aplicación aparece una notificación en la barra de estado y se debe deslizar para ver el contenido:

Reto: Desplegar una notificación cuando el reconocimiento de voz tenga resultados.

MEDIAPLAYER Descripción de la aplicación: Reproduce un archivo de audio WAV al iniciar la aplicación Interfaz de usuario: Sin interfaz de usuario Hardware: Dispositivo Android Nombre del Proyecto: MEDIAPLAYER Package Name: ejercicio22.android Application Label: Ejercicio22 El MediaPlayer es una función que reproduce archivos de audio, esto le da un toque decorativo a la aplicación por ejemplo en un robot se puede usar los sonidos de R2D2, el objeto esta implementado en el Core así que no es necesario alguna librería extra. Lo primero es declarar un Objeto tipo MediaPlayer con el nombre MP en el área de Sub Process_Globals. Después en el evento Activity_Create se inicializa poniendo la propiedad

113

Initialize, luego se indica el archivo a reproducir por medio de Load especificando el directorio y el nombre del archivo (previamente agregado con la pestaña Files), por último se reproduce con Play, el código queda de la siguiente manera:

Reto: Controlar el volumen multimedia con un SeekBar.

RTC Descripción de la aplicación: Obtiene la fecha y hora Interfaz de usuario: 6 Label, 1 Button Hardware: Dispositivo Android Nombre del Proyecto: RTC Package Name: ejercicio27.android Application Label: Ejercicio27 Este ejemplo utiliza la función de fecha y hora para implementar un reloj tipo calendario. Esta implementado en el Core por lo tanto no se necesita incluir alguna librería extra El layout deberá quedar de la siguiente manera:

114

No se necesita declarar algún objeto específico para hora y fecha, pero si se necesita una variable para guardar el tiempo actual, que debe ser una variable Long ya que la dimensión de datos en grande, al inicio un MSGBOX muestra la fecha y hora actual en un formato por medio de la función DateTime.Now(), después a través de las demás funciones se descompone por horas, minutos, etc. , para actualizar el tiempo se utiliza el Button1, el código queda de la siguiente manera:

Declaración de variables y objetos:

Inicialización:

115

Actualización con el Button1:

El resultado de la aplicación será el siguiente:

116

Reto: Actualización automática del tiempo.

GPS Descripción de la aplicación: Muestra la información de los satélites GPS Interfaz de usuario: 4 Label Hardware: Dispositivo Android Nombre del Proyecto: GPS Package Name: ejercicio26.android Application Label: Ejercicio26 El sensor GPS indica la posición actual y el estado de los satélites a los que está conectado el dispositivo Android. La funcionalidad para poder acceder al GPS es por medio de la librería GPS. Esta función requiere una conexión de dato activa y habilitar el uso de satélites GPS en el menú del dispositivo Ajustes->Ubicación Y Seguridad->Usar Satélites GPS. El layout deberá quedar como se muestra en la imagen

El objeto GPS debe de ser declarado en Sub Process_Globals, para no declararlo cada vez que necesite utilizarlizarse. El código queda de la siguiente manera:

117

El segundo paso es iniciar el objeto GPS, utilizando el parámetro Initialize, el código queda de la siguiente manera:

En Activity_Resume se verifica si el GPS está activado por medio de GPSEnabled, si no lo esta se envía un mensaje al usuario para activarlo, en caso de estar activado se pone en funcionamiento por medio de Start (), los dos ceros se refieren a el tiempo mínimo y distancia mínima a la que sea desea leer los cambios, generándose un evento cuando uno de los dos ha cambiado de valor, en este caso trabajara a la máxima frecuencia y resolución, en el evento Activity_Pause se detiene el GPS con Stop el código queda de la siguiente manera:

El GPS responde a tres eventos LocationChanged, UserEnabled y GpsStatus. En este ejemplo se utiliza el primero y el ultimo.

118

En el evento LocationChanged se obtiene la información de la posición (latitud, longitud y velocidad) por medio de las propiedades ConverToMinutes() y Speed, Después se muestra el resultado en los Label1, Label2 y Label1 respectivamente. En el evento GpsStatus se obtiene por medio de un ciclo For que va de 0 hasta la cantidad de satélites conectados, en la Label4 se muestra esta información. Es necesario probar la aplicación en el dispositivo real. Reto: Agregar cada satélite encontrado en un View Spinner y mostrar su información en un MSGBOX al tocar el Ítem.

119

En este capítulo se construirá el hardware necesario para establecer interfaces con dispositivos Android, se considera que el lector tiene experiencia en la construcción de circuitos impresos, se proporciona la lista de materiales, el diagrama esquemático y el PCB, el proyecto se encuentra en la carpeta PCB del CD.

PIC USB La tarjeta PIC USB está diseñada para la implementación rápida de prototipos ya que su firmware puede ser actualizado desde una conexión USB y la distribución de los componentes electrónicos facilita la conexión de hardware extra, está basada en el microcontrolador PIC18F2550 a continuación se describen las partes más importantes:

ENTRADA USB conecta la tarjeta a través del USB a la computadora para actualizar el firmware ALIMENTACION EXTERNA entrada de pilas o fuente de alimentación. Rango de 6 a 30 V.

120

SELECTOR DE ALIMENTACION a través de un jumper se selecciona si la tarjeta se alimenta desde el USB o a través de la alimentación externa. PUERTOS I/O 0-9 entradas y salidas correspondientes al PORTC (8 y 9) con función especial de UART y al PORTB (0-7) con funciones especiales de bus I2C e Interrupciones. PUERTOS I/O 10-12 entradas y salidas correspondientes al PORTC con función especial de salidas PWM. PUERTOS I/O 13-17 entradas y salidas correspondientes al PORTA con función especial de entradas analógicas. BOOT botón para entrar en modo boot. LED POWER indicador de alimentación. LED RUN indicador de modo boot. PUERTO ICSP conector para actualización de firmware por medio de un programador de microcontroladores La lista de materiales necesarios para su construcción es la siguiente: 1 Microcontrolador PIC PIC18F2550 1 Cristal de cuarzo de 20 MHZ 1 Regulador de 5v LM7805 2 LED de 3 mm 1 Push Button 2 Capacitores electrolíticos de 47 uf 1 Capacitor cerámico de 0.1 uf 1 Capacitor cerámico de 470 nf 2 Resistor de 330 ohm 1 Resistor de 10 k 1 Base para CI de 28 Pines 1 Conector USB tipo B hembra 1 Terminal de 2 pines 1 Tira de pines macho 1 Tira de pines Hembra 1 Jumper 1 Placa fenólica de una cara de 5x10 El diagrama esquemático se muestra a continuación

121

122

Los componentes deben quedar montados según la siguiente imagen:

El PCB es el siguiente:

La tarjeta terminada deberá quedar de la siguiente forma:

123

El siguiente paso es programar el microcontrolador a través de un programador externo a través del puerto ICSP el archivo a descargar al microcontrolador se llama Bootloader.hex se encuentra en la carpeta HEX del CD, a continuación se detalla el orden de los pines en la tarjeta.

Para verificar el funcionamiento de la tarjeta primero se debe energizar, el LED POWER deberá encender, después conectar el cable USB y presionar el botón BOOT, la computadora deberá reconocer el dispositivo y en breve deberá parpadear el LED RUN.

MODULO BLUETOOTH Esta modulo facilita la conexión con la tarjeta PIC USB a través de una conexión UART, está basado en el dispositivo HC-06 que actúa como un puerto serie para establecer la conexión con un dispositivo Android:

BLUETOOTH HC-06 dispositivo bluetooth modelo HC-06 LED STATUS indica el estado de la conexión. RESISTORES adaptan los niveles de voltaje para compatibilidad 5V.

124

REGULADOR 3.3V proporciona alimentación al módulo bluetooth

La lista de materiales necesarios para su construcción es la siguiente: 1 Bluetooth HC-06 1 Regulador 3.3 V 1 LED 1 Resistor 330 ohm 1 Resistor 10 k 1 Resistor 15 K 4 Pines 1 Placa fenólica una cara 5x5 El diagrama esquemático se muestra a continuación

Los componentes en rojo van en la parte sin cobre de la placa y los componentes en gris donde están las pistas ya que son de montaje superficia , deben quedar montados según la siguiente imagen:

125

En caso de utilizar un regulador diferente los pines GND deben quedar unidos y el orden de las conexiones se muestra en la imagen:

El PCB es el siguiente:

La tarjeta terminada deberá quedar de la siguiente forma:

Para verificar el funcionamiento del módulo bluetooth se debe alimentar por medio de los pines VDD Y GND con 5v, esto se puede lograr conectándolo a la tarjeta PIC USB, a continuación se detalla la interfaz UART del módulo y su conexión con la tarjeta:

126

Y la conexión con la tarjeta PIC USB debe quedar de la siguiente forma:

La siguiente figura muestra el modulo conectado a la tarjeta:

El último paso es encontrar el modulo Bluetooth con el dispositivo Android aparecerá con el nombre Linvor

127

IOIO BOARD La tarjeta IOIO DE Sparkfun es un hardware dedicado a la interfaz con dispositivos Android utilizando la depuración, actúa como un HOST USB, para mejorar la alimentación de la tarjeta se ha diseñado un adaptador

ENTRADA USB proporciona alimentación a la tarjeta IOIO ALIMENTACION EXTERNA entrada de pilas o fuente de alimentación. Rango de 5 a 30 V. SELECTOR DE ALIMENTACION a través de un jumper se selecciona si la tarjeta se alimenta desde el USB o a través de la alimentación externa. PUERTOS I/O 1-18 entradas y salidas dela tarjeta IOIO. PUERTOS I/O 33-48 entradas y salidas dela tarjeta IOIO. POWER switch on-off de alimentación. ENTRADA PARA CARGA proporciona energía a las baterías.

128

La lista de materiales necesarios para su construcción es la siguiente: 1 tarjeta IOIO 3 pines macho 4 Tiras de pines hembra 1 Jack o bornera para PCB 1 Terminal de 2 pines 1 Conector USB tipo B 1 Microswitch 1 Jumper 1 Placa fenólica de una cara de 5x10

El diagrama esquemático se muestra a continuación

Los componentes deben quedar montados según la siguiente imagen:

129

El PCB es el siguiente:

Para la base del IOIO se ha usado pines hembra dobles para mayor estabilidad, pero basta con pines sencillos, el área con driles (huecos) se puede usar para una interfaz UART e I2C los grupos de 4 son para los pines y los demás para colocar 2 resistencias de 10k, la tarjeta terminada deberá quedar de la siguiente forma:

Para comprobar el funcionamiento se debe energizar la tarjeta (se encenderá el LED rojo ) y conectar el dispositivo Android al IOIO, deberá estar activada la depuración, la tarjeta será reconocida por el dispositivo y el LED amarillo del IOIO dará un destello.

130

En este capítulo se desarrollaran aplicaciones para conectar hardware externo a un dispositivo Android para controlar cargas o para leer el estado de algún sensor, es recomendable contar con un protoboard y algunos componentes electrónicos como LED’s, Potenciómetros, Servomotores, para hacer más interactivo el aprendizaje, se utilizara el software PICC para los programas de la tarjeta PIC USB.

INTERFAZ BLUETOOTH Como primer ejemplo se desarrollara la aplicación más sencilla que consiste en construir un esqueleto de aplicación con las funciones básicas como conectarse a un dispositivo y notificar, esto servirá de base para desarrollar futuras aplicaciones para una interfaz bluetooth. Las aplicaciones listas para instalar y probar se encuentran en la carpeta APK del CD. El código fuente y el proyecto de las aplicaciones se encuentran en la carpeta APLICACIONES ANDROID del CD El código fuente para la tarjeta PIC USB se encuentra en la carpeta APLICACIONES PIC del CD, también en este apartado se explica el algoritmo para establecer la interfaz.

BLUETOOTH Descripción de la aplicación: Realiza funciones básicas para una interfaz bluetooth Interfaz de usuario: Sin Layout Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta PIC USB Nombre del Proyecto: BLUETOOTH Package Name: ejercicio23.android Application Label: Ejercicio23

131

Para utilizar el Bluetooth en Basic4android se debe incluir la librería Serial al proyecto ya que este es el perfil más sencillo a utilizar. Para una aplicación bluetooth se debe conocer ciertos puntos como el estado de la conexión, la lista de dispositivos vinculados, el dispositivo con el que se quiere trabajar, etc. El primer paso es declarar un objeto tipo Serial en el área de Process_Globals para poder utilizar el bluetooth.

El siguiente paso es inicializar el bluetooth creando un evento a través de la propiedad Initialize, el código se muestra a continuación:

El primer punto a considerar es monitorear el estado del bluetooth, para avisarle al usuario que lo active en caso de no estarlo ya que no es posible usarlo si está activado, y si está activado tiene que ponerse a escuchar las conexiones entrantes para que otros dispositivos puedan hacer peticiones de conexión. El estado se obtiene a través de la propiedad IsEnabled y para escuchar conexiones es a través de la propiedad Listen, el momento efectivo para hacerlo es en el evento Activity_Resume, el código queda de la siguiente manera:

132

Es posible correr la aplicación y verificar el funcionamiento, de otra forma el siguiente punto a considerar es obtener la lista de dispositivos apareados o vinculados, este resulta ser el paso más complejo en todo el proceso. El momento más adecuado para obtener la lista es cuando el usuario intenta conectarse a un dispositivo bluetooth como el módulo de la tarjeta PIC USB, como no se diseñó ningún Layout el medio para iniciar el proceso de conexión será un ítem de menú, esto resulta cómodo ya que solo ocupara la pantalla cuando sea necesario, por lo tanto se comenzara por construir 2 ítem de menú para controlar la conexión y desconexión. El código debe quedar de la siguiente forma:

Y sus respectivos eventos quedan de la siguiente manera:

Para obtener la lista de dispositivos apareados se necesita una lista y un mapa que básicamente son arreglos de objetos que almacenan cadenas de caracteres de información, como por ejemplo en el caso del bluetooth se almacena el nombre de un dispositivo y su dirección MAC, ya que pueden ser varios dispositivos la búsqueda se realiza con un ciclo For, las variables se deben definir como se muestra a continuación:

133

Primero se debe guardar en un mapa la lista de dispositivos apareados mediante GetpairedDevices Después se inicializa la lista, luego se copia a la lista todo el contenido del mapa, el tamaño del mapa se obtiene con Size, y con GetKeyAt () se obtiene cada elemento del mapa.

Este proceso se debe implementar tal y como se muestra en el código de ejemplo, no es necesario tratar de entender que es lo que hace cada instrucción si no el algoritmo. El lector tal vez se preguntara por que se usa un mapa y no se almacena directamente en una lista, la razón es porque la propiedad GetPairedDevices retorna un mapa, el código debe quedar implementado como se muestra a continuación:

Ya que se ha obtenido la lista de dispositivos apareados el siguiente paso es desplegar la lista para que el usuario seleccione un dispositivo para conectarse. Esto se logra con el comando InputList que necesita como parámetros la lista que debe mostrar (esta es otra razón por lo cual se usa una lista), el título, y el dispositivo seleccionado por default (-1 indica que no se selecciona ninguno).

InputList(Lista, "Seleccionar Dispositivo", -1)

134

El código queda de la siguiente manera:

Hasta el momento al correr la aplicación el resultado será el siguiente:

Se puede apreciar que un InputList es un conjunto de RadioButtons y la propiedad es que cuando están agrupados solo uno puede seleccionarse, esto es eficaz para seleccionar el dispositivo para conectarse (ahí el motivo de usar lista). El siguiente paso es realizar la conexión con el dispositivo seleccionado, en el código mostrado anteriormente el InputList se le asignó a la variable Dispositivo_Selecionado, esta variable debe ser declarada como tipo int, antes de dar la orden conectar se debe saber si se seleccionó algún dispositivo de la lista, esto se logra por medio de DialogResponse.Cancel . Por último se da la orden conectar por medio de Connect, que resulta ser una instrucción más compleja pero lo que

135

Hace es obtener la dirección MAC del dispositivo seleccionado para conectarse. El código modificado se muestra a continuación:

El penúltimo paso es monitorear el estado de la conexión con el evento Connected del bluetooth que por medio de la variable Success indica si la operación fue exitosa o hubo algún problema, Ya que esta variable es local no se podrá usar en otra parte del código para preguntar el estado de la conexión, para ello se requiere usar una variable auxiliar de tipo Boolean, el código correspondiente se muestra en la siguiente imagen:

En el evento Connected se pregunta si la conexión fue exitosa, se establece el valor de la variable Conectado y por medio de un mensaje Toast se notifica al usuario.

136

El último paso es finalizar la conexión por medio de la propiedad Disconnect del bluetooth, el ítem de menú (desconectar) y el cierre de la aplicación controlan la desconexión, solo es necesario desconectarse cuando se encuentra conectado a un dispositivo y para ello se utiliza la variable Conectado, el código debe quedar de la siguiente manera:

Con esto se ha concluido el desarrollo de la aplicación base para bluetooth, el siguiente paso es preparar la interfaz. El resultado al conectarse con algún dispositivo será el siguiente:

137

LA INTERFAZ El modulo bluetooth viene con las siguientes configuraciones de fábrica: BaudRate: 9600 Paridad: N (sin paridad) Bits de datos: 8 Bits de parada: 1 ID: linvor Password: 1234 Al conectar el modulo bluetooth a la tarjeta PIC USB y energizarlo el LED comenzara a parpadear y al realizar la búsqueda con el dispositivo Android aparecerá como se muestra en la siguiente imagen

138

Al seleccionar el dispositivo de nombre linvor aparecerá un dialogo pidiendo la contraseña, introducir 1234:

El dispositivo aparecerá con la leyenda “vinculado.Deconectado”, como se muestra en la imagen de abajo:

Con esto queda todo listo para continuar con el siguiente ejemplo.

BLUETOOTH TX Descripción de la aplicación: Controla un LED por medio de bluetooth Interfaz de usuario: 1 Label, 2 Button

139

Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta PIC USB, LED Nombre del Proyecto: BLUETOOTH TX Package Name: ejercicio24.android Application Label: Ejercicio24

Utilizando el ejemplo anterior se agregara la función de enviar datos a través de bluetooth hacia el modulo conectado a la tarjeta PICUSB, el objetivo es prender y apagar un LED conectado al pin 0. El algoritmo es sencillo, consiste en enviar un carácter “1” para encender y “2” para apagar. El layout debe quedar como se muestra en la siguiente imagen:

El medio necesario para el envió de caracteres se conoce como TextWriter, este objeto se debe declarar en el área Sub Globals, el código queda como se muestra a continuación:

140

El siguiente paso es inicializar el TextWriter y el momento preciso es cuando se ha establecido la conexión, se debe inicializar como un medio de salida de datos, para ello se usa la propiedad OutputStream del bluetooth, el código debe quedar de la siguiente manera:

Para enviar caracteres a traves del TextWriter se utiliza la propiedad Write() especificando los caracteres a enviar, la funcion Flush limpia el TexWriter, se utiliza la variable conectado ya que si se envian datos sin una conexión activa Android arrojara un error.Por ultimo el estado del LED se indica en un Label. El codigo queda de la siguiente manera:

141

La tarjeta PIC USB debe tener conectado un LED como se muestra en la imagen

El código fuente se encuentra en la carpeta APLICACIONES PIC del CD, para editarlo abrir el archivo BLUETOOTH_RX.c el código está desarrollado en PIC C de CCS. El archivo listo para su descarga a la tarjeta se encuentra en la carpeta HEX del CD, conectar la tarjeta PIC USB mientras se presiona el botón BOOT hasta que el LED RUN comience a parpadear, después abrir el programa PICUSB LOADER que se encuentra en la carpeta TOOLS del CD, el resultado será una ventana como esta:

Device attached indica que la tarjeta esta lista, para descargar el archivo dar clic en el botón Importar y buscar el archivo BLUETOOTH_RX.hex, después dar clic al botón Programar, el programa indicara el progreso como se muestra en la siguiente imagen:

142

El último paso es dar clic en el botón Correr, el LED dejara de parpadear y el programa comenzara a funcionar.

BLUETOOTH RX Descripción de la aplicación: Muestra el carácter recibido por medio de bluetooth Interfaz de usuario: 1 Label Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta PIC USB Nombre del Proyecto: BLUETOOTH RX Package Name: ejercicio25.android Application Label: Ejercicio 25 Utilizando el ejercicio 23 se agregara la función de recibir datos a través de bluetooth enviados por el modulo conectado a la tarjeta PICUSB según el estado del botón BOOT, el objetivo es ver en un Label el carácter recibido. El layout debe quedar como se muestra en la siguiente imagen:

143

El medio necesario para la recepción de caracteres se conoce como TextReader, este objeto se debe declarar en el área Sub Globals. No existe un evento que responda cuando se ha recibido un carácter, por lo tanto es necesario preguntar periódicamente con un Timer, el código queda como se muestra a continuación:

El siguiente paso es inicializar el TextReader y el momento preciso es cuando se ha establecido la conexión tal como se hizo con el envío de caracteres, se debe inicializar como un medio de entrada de datos, para ello se usa la propiedad InputStream del bluetooth, en esta parte el Timer se habilita pero debe inicializarse para interrumpir cada 10 ms (no se muestra en la imagen puesto que se explicó anteriormente). El código debe quedar de la siguiente manera:

Para recibir caracteres a traves del TextReader se utiliza el evento del Timer y para leer los datos es necesario que se cumplan 2 cosas: que exista una conexión activa y el TextReader este listo, esto se verifica por medio de la variable Conectado y la propiedad Ready. Para mostrar los datos en el Label se utiliza la propiedad ReadLine, es importante que al momento de enviar el carácter

144

Con el microcontrolador se use el terminador de linea “\n” . El codigo queda de la siguiente manera:

El último paso es deshabilitar el Timer como se hizo al finalizar la conexión bluetooth, cuando se cierra la aplicación y cuando se desconecta, el código queda de la siguiente manera:

El código fuente se encuentra en la carpeta APLICACIONES PIC del CD, para editarlo abrir el archivo BLUETOOTH_TX.c el código está desarrollado en PIC C de CCS. Cargar el archivo BLUETOOTH_RX.hex a la tarjeta.

Reto: combinar los 2 ejercicios anteriores en una sola aplicación, El código fuente para interfaz se encuentra en la carpeta APLICACIONES PIC del CD, para editarlo abrir el archivo BLUETOOTH_RXTX.c el código está desarrollado en PIC C de CCS, cargar el archivo BLUETOOTH_RXTX.hex a la tarjeta.

145

INTERFAZ IOIO Como primer ejemplo se desarrollara la aplicación más sencilla que consiste en construir un esqueleto de aplicación con las funciones básicas para utilizar la tarjeta IOIO y controlar el LED OnBoard. Las aplicaciones listas para instalar y probar se encuentran en la carpeta APK del CD. El código fuente y el proyecto de las aplicaciones se encuentran en la carpeta APLICACIONES ANDROID del CD

IOIO Descripción de la aplicación: Controla el LED OnBoard de la tarjeta IOIO

Interfaz de usuario: 1 ToggleButton Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta IOIO, adaptador para IOIO Nombre del Proyecto: IOIO Package Name: ejercicio28.android Application Label: Ejercicio28 Para utilizar la tarjeta IOIO en Basic4android se deben incluir las librerías IOIO y IOIOlib al proyecto. El layout debe quedar como se muestra en la siguiente imagen:

146

Para una aplicación con IOIO el primer paso es declarar un objeto tipo IOIO y un objeto tipo DigitalOutput en el área de Sub Globals

El siguiente paso es inicializar el IOIO simplemente con la propiedad Initialize, después esperar la conexión de la tarjeta por medio de WaitForConnect, mostrar la versión de hardware, por ultimo abrir un PIN como salida en este caso el 0 ya que el LED OnBoard se conecta a ese pin, en caso de necesitar otra salida solo se debe cambiar el número, el código se muestra a continuación:

Al salir de la aplicación se debe cerrar los pines utilizados y desconectar de la tarjeta IOIO, esto se logra por medio de las propiedades Close Y Disconnect() respectivamente, el evento Activity_Pause queda de la siguiente manera:

147

Para controlar el encendido del LED se utiliza el evento CheckedChange del ToggleButton, a través de la propiedad Write se escribe el dato de salida, el LED se activa en bajo por lo que se usa el comando Not() para invertir el estado del ToggleButton en la escritura como se muestra en la siguiente imagen:

Al ejecutar la aplicación y conectar la tarjeta el resultado será el siguiente:

IOIO ANALOG Descripción de la aplicación: Muestra la lectura de una entrada analógica Interfaz de usuario: 1 ProgressBar, 1 Label Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta IOIO, adaptador para IOIO, Potenciómetro Nombre del Proyecto: IOIO ANALOG Package Name: ejercicio29.android

148

Application Label: Ejercicio29 . El layout debe quedar como se muestra en la siguiente imagen:

La diferencia con el ejercicio anterior es que se debe declarar un objeto tipo AnalogInput y al igual que en el ejemplo BLUETOOTH RX se utilizara un Timer para la lectura de datos, el código queda de la siguiente manera:

El Timer se debe inicializar a 30 milisegundos y habilitar justo después de que se conecta la tarjeta, en este caso se utiliza el pin 40 para abrir una entrada analógica en caso de necesitar otra entrada solo se debe cambiar el número (33-46), el código se muestra a continuación:

149

Al salir de la aplicación se debe deshabilitar el Timer, cerrar los pines utilizados y desconectar de la tarjeta IOIO, el evento Activity_Pause queda de la siguiente manera:

Para leer la entrada analógica se utiliza el evento Tick del Timer, a través de la propiedad Voltaje se obtiene la tensión de entrada en el pin analógico (no debe ser mayor de 3.3 v para no dañar el IOIO), y este valor es asignado a un Label, por último se hace un ajuste para representar el voltaje de entrada en un ProgressBar como se muestra en la siguiente imagen:

La tarjeta IOIO debe tener conectado un potenciómetro como se muestra en la imagen

150

Al ejecutar la aplicación y conectar la tarjeta el resultado será el siguiente:

IOIO PWM OUTPUT Descripción de la aplicación: Controla la intensidad de un LED o posición de un servo Interfaz de usuario: 1 SeekBar, 1 Label Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta IOIO, adaptador para IOIO, LED, Servo Nombre del Proyecto: IOIO PWM OUTPUT Package Name: ejercicio30.android Application Label: Ejercicio30

151 . El layout debe quedar como se muestra en la siguiente imagen:

La diferencia con el ejercicio anterior es que se debe declarar un objeto tipo PwmOutput, el código queda de la siguiente manera:

En este ejercicio se utiliza el pin 12 para abrir una salida PWM a 1 khz en caso de necesitar otra entrada solo se debe cambiar el número (3-7,9-14), el código se muestra a continuación:

152

Al salir de la aplicación se debe cerrar los pines utilizados y desconectar de la tarjeta IOIO, el evento Activity_Pause queda de la siguiente manera:

Para controlar la salida PWM se utiliza el evento ValueChanged del SeekBar, a través de la propiedad PulseWidth se controla el ancho de pulso de la salida PWM (de 0 a 1024), y este valor es asignado a un Label, pero este proceso se debe realizar solo si la salida PWM esta lista, esto se verifica por medio de la propiedad IsInitialized como se muestra en la siguiente imagen:

La tarjeta IOIO debe tener conectado un LED como se muestra en la imagen

También se puede conectar un servo como se muestra en la imagen

153

Al ejecutar la aplicación y conectar la tarjeta el resultado será el siguiente:

154

DESCRIPCION DROID es un Robot-Smartphone basado en una interfaz Bluetooth con la tarjeta PIC USB, Es un medio didáctico para el desarrollo de aplicaciones móviles, utiliza el teléfono como accesorio o como cerebro, aprovechando la potencia de los procesadores de un teléfono inteligente y sensores, es accesible, expandible, ya que aumenta la funcionalidad del robot, es económico y de fácil construcción.

ESTRUCTURA MECÁNICA El chasis está construido con PVC espumado mejor conocido como Sintra es un material liviano, resistente, termoformable, autoextinguible, no absorbe la humedad, se puede cortar, aserrar, pintar, perforar, etc., Sin embargo el lector puede utilizar otro material para construir su estructura ya que dependerá del tipo de motores que utilice, los motores utilizados en el robot fueron sacados de unos carritos de juguete, que tienen una relación de 50:1. Loa motores recomendados son los motorreductores de plástico ya que las ruedas están diseñadas para estos motores. La Sintra está disponible en modo de pliegos de diferentes tamaños y colores, un cúter y kola loca será necesario para cortar las piezas y unirlas para formar la estructura. En la imagen de abajo se muestra algunos pliegos de Sintra

Los motorreductores de plástico se pueden encontrar en tiendas especializadas de robótica, al igual que las ruedas. Una buena elección de motorreductor es con la relación 1:48, que

155 Proporcionará 200 rpm y un rango de alimentación de 3 a 12 v. En la imagen de abajo se muestra un motorreductor y las ruedas de la empresa Robodacta.

Con paciencia y dedicación se puede construir una estructura utilizando los materiales mencionados anteriormente y lograr tener montados los motores, incluso una base hecha de trovicel para colocar el Smartphone como se muestra en la siguiente imagen del robot Androidmie.

Droid es mucho más simple debido al reciclaje de los motores y ruedas, por lo que ha quedado de la siguiente forma:

156

ELECTRONICA La electrónica consta de tres partes una es la tarjeta PIC USB, la segunda el modulo bluetooth y la tercera el DROID SHIELD, este último es el encargado de proporcionar el driver para controlar los motores, la conexión de la energía y los sensores. El proyecto se encuentra en la carpeta PCB del CD. El DROID SHIELD está diseñado para albergar la tarjeta PIC USB y utiliza un chip SN75441110NE como driver de los motores, a continuación se describen las partes más importantes:

ENTRADA PARA PILAS terminal de 2 tornillos para alimentar el circuito CONECTOR MOTOR L terminal de 2 tornillos para conectar el motor izquierdo. CONECTOR MOTOR R terminal de 2 tornillos para conectar el motor derecho DRIVER chip SN754410NE puente H BASE PARA PIC USB tiras de pines hembra para conectar la tarjeta PIC USB CONECTOR SENSOR L 3 pines macho para conectar el sensor de proximidad izquierdo CONECTOR SENSOR R 3 pines macho para conectar el sensor de proximidad derecho SENSORES EXTRA área para conectar hasta 3 sensores analógicos

157

La lista de materiales necesarios para su construcción es la siguiente: 1 Driver Puente H SN754410NE 1 Base para CI de 16 Pines 3 Terminal mini de 2 pines 2 Tira de 3 pines macho 1 Tira de pines Hembra 1 Placa fenólica de una cara de 5x10 El diagrama esquemático se muestra a continuación

158

Los componentes deben quedar montados según la siguiente imagen:

El PCB es el siguiente:

Adicionalmente se puede dar un acabado a la placa con los Labels

La tarjeta terminada deberá quedar de la siguiente forma:

159

Droid posee 2 sensores de proximidad GP2Y0A21YK0F de la marca Sharp que miden la distancia a la que se encuentra un objeto en un rango de 10 a 80 cm, estos sensores entregan una tensión analógica dependiendo de la distancia, funcionan con un voltaje de alimentación de 4.5 a 5.5 v y un consumo típico de 30 mA, en la siguiente figura se muestra el sensor y las conexiones necesarias:

Para conectarlos es necesario un cable especial llamado JST de 3 vías, el sensor y cable se pueden encontrar en tiendas como Robodacta y Pololu.

Los sensores deben quedar conectados como se muestra en la siguiente figura:

160

Los sensores cuentan con unos orificios en los costados para atornillarse, en el robot han quedado de la siguiente manera: .

Para la conexión de los motores es necesario soldar entre los terminales de cada motor un capacitor de 0.1 uf para reducir el ruido eléctrico que generan, y la conexión en el DROID SHIELD debe quedar como se muestra en la siguiente imagen:

161

El robot utiliza 6 pilas recargables AAA de Ni-Cd conectadas en serie para proporcionar un voltaje 7.2 V , y una corriente de 1 A, se puede usar cualquier otra pila con la restricción en corriente de hasta 2 A y un voltaje de 12 V como máximo, en la siguiente imagen se muestra como se deben conectar:

El robot con toda la electrónica montada queda como se muestra en la siguiente imagen:

162

Para verificar el funcionamiento de los motores cargar el archivo TEST_MOTORES.HEX contenido en la carpeta HEX del CD, el robot realizara la siguiente secuencia: Adelante-Atrás-IzquierdaDerecha-Detenido. Para verificar el funcionamiento de los sensores cargar el archivo TEST_SENSORES.HEX contenido en la carpeta HEX del CD, el LED RUN de la tarjeta PIC USB deberá encender al acercar un objeto.

SOFTWARE El software del robot consta de dos partes: uno es el programa del Microcontrolador y el otro la aplicación para el dispositivo Android Una vez terminado el montaje se debe cargar el archivo DROID CONTROLLER.HEX contenido en la carpeta HEX del CD, el LED RUN de la tarjeta PIC USB deberá parpadear lentamente. El código fuente del programa del Microcontrolador es el archivo DROID CONTROLLER.c contenido en la carpeta APLICACIONES PIC del CD, está desarrollado en PIC C de CCS. El programa del Microcontrolador se encarga de controlar la velocidad y giro de los motores, procesar los datos del bluetooth y leer los sensores. El protocolo de comunicación es simple: para que el robot se mueva en una dirección la aplicación del dispositivo Android debe enviar un carácter numérico del 1 al 8, y el estado de los sensores se envía simplemente con el valor. También se debe instalar en el dispositivo Android el archivo DROID.APK contenido en la carpeta APK del CD, El código fuente es el archivo DROID contenido en la carpeta APLICACIONES ANDROID del CD, esta aplicación se proporciona como una base para implementación de proyectos en robótica con dispositivos Android. Al iniciar la aplicación aparecerá una pantalla como la siguiente:

163

Después de dar clic al botón aceptar aparecerá una pantalla que simula los ojos del robot y sus principales funciones se describen a continuación:

BOTON PLAY inicia el funcionamiento del robot BOTON SALIR libera el hardware y cierra la aplicación BOTON CONECTAR selecciona el dispositivo bluetooth y el modo de conexión ESTADO muestra las acciones realizadas por el robot NIVEL DE SENSOR 1 muestra una representación de la lectura del sensor de proximidad izquierdo NIVEL DE SENSOR 2 muestra una representación de la lectura del sensor de proximidad derecho PREVIEW DE LA CAMARA muestra la vista previa de la cámara OJOS DEL ROBOT simula el estado de ánimo del robot

El primer paso para usar la aplicación es conectarse a un dispositivo bluetooth tocando el botón CONECTAR, aparecerá un cuadro de dialogo mostrando los diferentes modos de conexión como se muestra en la siguiente imagen:

164

Existen 2 modos de conexión: CONTROLLER o REMOTE, el primero es obligatorio ya que se conecta a el modulo bluetooth del controlador del robot, el modo REMOTE sirve para conectarse a otro dispositivo Android, por ejemplo para controlar el robot desde una Tablet, al tocar el botón CONTROLLER aparecerá la lista de dispositivos apareados:

Se deberá seleccionar el dispositivo correspondiente al módulo bluetooth en este caso linvor, cuando se establezca la conexión aparecerán 2 diferentes pantallas, una para conexión exitosa y otra para conexión errónea:

165

El siguiente paso es seleccionar un modo de funcionamiento, presionando el botón menú aparecerá un ítem para seleccionar el modo:

Existen 3 modos de funcionamiento: BRAIN, REMOTE C y OTHER. En el modo BRAIN el dispositivo Android actúa como cerebro del robot , en este modo se muestra un preview de la cámara y la función principal del código es que el robot pueda ser controlado desde otro dispositivo; en el modo REMOTE C el dispositivo Android actúa como un control remoto, es decir se retira de la base del robot para controlar por medio del acelerómetro los movimientos; El modo OTHER está diseñado para alguna otra función, el usuario puede modificar el código y agregar sus funciones, por ejemplo controlar el robot por voz, detectar metales, etc. Sin embargo la función demo implementada es evadir obstáculos mediante los sensores de proximidad. En todos los modos el robot reproduce sonidos de R2D2, en la siguiente imagen se muestran los 3 modos.

166

Algunas prácticas propuestas son las siguientes: 1. 2. 3. 4. 5. 6. 7.

Controlar los movimientos del robot a través del reconocimiento de voz Buscar metales por medio del magnetómetro Evadir obstáculos por medio del sensor de proximidad del teléfono Clasificar objetos por medio de códigos QR Mostrar la ubicación del Robot en google usando el GPS. Formar una red de 2 robots para implementar una coreografía de baile simple. Agregar sensores al robot para implementar el programa sigue líneas en el dispositivo Android 8. Agregar sensores al robot para implementar el programa luchador de sumo en el dispositivo 9. Diseñar un controlador con la tarjeta IOIO y la aplicación del Robot 10. Reconocimiento de objetos a través de la cámara

167

En el bloques anteriores se desarrollaron aplicaciones básicas y con librerías para familiarizarse con el entorno desarrollo y las funciones de Android, en este apartado se realizaran aplicaciones para implementar técnicas y algoritmos en la recepción y envió de datos a través de bluetooth y configuraciones avanzadas del dispositivo. Al igual que en el capítulo anterior las aplicaciones listas para instalar y probar se encuentran en la carpeta APK del CD, también el código fuente y el proyecto de las aplicaciones se encuentran en la carpeta APLICACIONES ANDROID del CD

SEEKBAR Y PWM Descripción de la aplicación: Controla la intensidad de un LED Interfaz de usuario: 1 Label, 1 SeekBar Hardware: Dispositivo Android, Tarjeta PIC USB, Modulo Bluetooth, LED Nombre del Proyecto: SEEKBAR_Y_PWM Package Name: SEEKBAR_Y_PWM.ANDROID Application Label: SEEKBAR Y PWM Técnica: Envió de más de un carácter por bluetooth y su procesamiento con el microcontrolador El Layout deberá quedar como se muestra a continuación:

168

Esta aplicación es muy similar a la desarrollada en el ejercicio 24 en la que un botón controla el encendido de un LED enviando un carácter. La diferencia es que ahora un SeekBar controla la intensidad de un LED por lo que se requiere enviar más de un carácter, la técnica consiste en implementar un protocolo de comunicaciones propio, que contenga un carácter de inicio, los datos y un carácter de fin. En este ejemplo se utiliza como delimitadores los paréntesis entonces el protocolo queda de la siguiente forma: (datos) Entonces al enviar los caracteres en el evento del SeekBar el código quedara dela siguiente manera:

Se puede apreciar que el envío no es difícil, pero el procesamiento de la cadena de caracteres en el Microcontrolador es un poco más elaborado. Para empezar el Microcontrolador debe detectar el momento en que llega el carácter “(“, después guardar los datos y la posición en la que se encuentran, detectar el carácter “)“ para reiniciar el ciclo, y por ultimo convertir esa cadena de texto en un valor. Es recomendable el uso de interrupciones por UART para evitar la pérdida de datos. Teniendo en cuenta que el SeekBar Varia de 0 a 100 el mínimo numero de caracteres que puede enviar son 3 y el máximo son 5, para (0) y (100) respectivamente. Entonces es necesario declarar una variable char en forma de arreglo para guardar los datos, siendo 5 la dimensión mínima, el código del Microcontrolador usa para ello la siguiente línea: char dato[10]; Para detectar cada carácter recibido se utiliza la función Kbhit() , al recibir cada carácter se debe ir guardando en la variable dato[] especificando la posición en los corchetes, debido a que no se

169

Sabe en qué momento se recibirán 3,4 o 5 caracteres la posición de los datos y del carácter de fin “)” será variable, por lo tanto se usa la variable entera Position para usarla como apuntador como se muestra a continuación: if(kbhit()) { dato[position]=getc(); } El siguiente paso es detectar el carácter de inicio, servirá para saber que inicia la trama e indicar mediante una variable llamada Inicio que ya se puede incrementar la variable Position y acomodar el dato en la siguiente posición del arreglo: if(dato[position]==40) { inicio=1; } Luego se incrementa la posición mediante la variable Inicio: if(inicio==1) { position=position+1; } El siguiente paso es detectar el fin de la cadena para reiniciar el ciclo, es decir hacer el apuntador Position = 0, la bandera Inicio=0 y guardar la posición en la que terminan los datos, que siempre es una posición antes que el carácter “)”. El código queda de la siguiente manera: if(dato[position]==41) { fin=position-1; inicio=0; position=0; } Ahora solo resta extraer los datos y convertirlos a un valor numérico, si se han recibido 3 caracteres (para un valor del SeekBar de un digito por ejemplo 5) las variables quedan como Position=2, Fin=1, por lo tanto los caracteres se han acomodado de la siguiente forma: dato[0]=”(“, dato[1]=”5“ y dato*2]=”)“. Si se han recibido 4 caracteres (para un valor del SeekBar de dos dígitos

170

Por ejemplo 20) las variables quedan como Position=3, Fin=2, por lo tanto los caracteres se han acomodado de la siguiente forma: dato [0]=”(“, dato[1]=”2“, dato*2]=”0“ y dato*3]=”)“. Si se han recibido 5 caracteres (para un valor del SeekBar de tres dígitos por ejemplo 100) las variables quedan como Position=4, Fin=3, por lo tanto los caracteres se han acomodado de la siguiente forma: dato [0]=”(“, dato[1]=”1“, dato*2]=”0“, dato*3]=”0“ y dato*4]=”)“. Conociendo estos valores es posible convertir a un valor numérico, como los caracteres se envían en código ASCII el carácter “0” corresponde al valor decimal 48, por lo tanto se le resta esa cantidad, de esta forma se obtienen los dígitos. El último paso es formar la cantidad multiplicando cada digito por su valor correspondiente (unidad, decena y centena) y sumarlos, el código queda de la siguiente manera: if(fin==1) pwm=dato[1]-48; if(fin==2) pwm=(dato[1]-48)*10+(dato[2]-48); if(fin==3) pwm=(dato[1]-48)*100+(dato[2]-48)*10+(dato[3]-48); El valor del SeekBar ha quedado guardado en la variable pwm. El código correspondiente a la tarjeta PIC USB se encuentra en la carpeta APLICACIONES PIC del CD con el nombre SEEKBAR_Y_PWM.c

PROGRESSBAR Y ADC

Descripción de la aplicación: Muestra la lectura de un canal analógico Interfaz de usuario: 1 Label, 1 ProgressBar Hardware: Dispositivo Android, Tarjeta PIC USB, Modulo Bluetooth, Potenciómetro Nombre del Proyecto: PROGRESSBAR_Y_ADC Package Name: PROGRESSBAR_Y_ADC.ANDROID Application Label: PROGRESSBAR Y ADC Técnica: Envió de más de un carácter por bluetooth con el microcontrolador

El Layout deberá quedar como se muestra a continuación:

171

Esta aplicación es muy similar a la desarrollada en el ejercicio 25 en la que el Boton BOOT de la tarjeta PIC envía un carácter de acuerdo a su estado. La diferencia es que ahora se lee un canal analógico de la tarjeta por lo que se requiere enviar más de un carácter, la técnica en el caso del microcontrolador consiste en formatear la cadena usando instrucciones printf, en basic4android la recepción de los caracteres y su conversión es facilitada por medio del lenguaje por lo que los datos de entrada se pueden asignar directamente al Label y al ProgressBar

Entonces al recibir los caracteres en el evento del Timer el código quedara dela siguiente manera:

Para el envío de datos con el microcontrolador se usa la instrucción printf y su sintaxis es la siguiente: Printf(“ “);

172

Para enviar un valor fijo basta con poner el texto entre “ “ , por ejemplo para enviar un 100 el comando queda de la siguiente manera: Printf(“100“); Sin embargo la lectura del ADC es una cantidad variable, para enviar variables se puede usar los siguientes formateadores de cadena: c s u d Lu Ld x X f g e

Carácter en ASCII Cadena Entero sin signo en formato decimal Entero con signo en formato decimal Entero sin signo de 16 bit en formato decimal Entero con signo de 16 bit en formato decimal Entero en formato hexadecimal (minúsculas) Entero en formato hexadecimal (mayúsculas) Flotante con punto decimal Flotante redondeado Flotante en exponencial

A cada modificador se le antepone el símbolo % y con una coma después del segundo símbolo “ se especifica la variable a enviar, por ejemplo para enviar una variable llamada S1 : Printf(“%u“,S1); Otros modificadores muy utilizados son el retorno de carro y carácter de salto de línea “\r” y “\n” Por lo tanto si en Basic4Android se utiliza la función ReadLine será necesario enviar el carácter de salto de línea al final, el código quedara de la siguiente manera: Printf(“%u\n“,S1); Por último el ADC retorna valores de 0 a 255 mientras que el ProgressBar va de 0 a 100, en el código del microcontrolador se hace un ajuste dividiendo la variable entre 2 para hacer más aproximada la representación en el ProgressBar, se debe incluir un pequeño retardo de algunos milisegundos para no sobrecargar de datos al sistema Android, el código queda de la siguiente manera:

printf("%u\n",ADC/2); delay_ms(100);

173

El código correspondiente a la tarjeta PIC USB se encuentra en la carpeta APLICACIONES PIC del CD con el nombre PROGRESSBAR_Y_ADC.c

LED RGB Descripción de la aplicación: Controla los colores de un LED RGB Interfaz de usuario: 1 Label, 3 SeekBar Hardware: Dispositivo Android, Tarjeta PIC USB, Modulo Bluetooth, LED RGB Nombre del Proyecto: LED_RGB Package Name: LED_RGB.ANDROID Application Label: LED RGB Técnica: Envió de más de un carácter y más de una variable por bluetooth y su procesamiento con el microcontrolador El Layout deberá quedar como se muestra a continuación:

Esta aplicación es muy similar a la desarrollada en el ejercicio SEEKBAR_Y_PWM en la que un SeekBar controla la intensidad de un LED enviando más de un carácter. La diferencia es que ahora son 3 SeekBar controlando la intensidad de 3 LED (correspondientes a Rojo, Verde y Azul del LED) por lo que se requiere enviar más de un carácter y una forma de diferenciar un valor de otro, la técnica consiste agregar un identificador único para cada variable al protocolo de comunicaciones propio,. En este ejemplo se utiliza como identificadores las letras R,G y B por lo que el protocolo queda de la siguiente manera (datosIdenfiticador)

174

Entonces al enviar los caracteres en el evento de cada SeekBar se muestra en los Label la posición y se utiliza la instrucción Colors.RGB() para colorear el Label, el código quedara dela siguiente manera:

Al igual que el ejemplo mencionado anteriormente el envío no es difícil, y en cuanto al programa del microcontrolador solo habrá que agregar el código para detectar cada identificador Para detectar cada carácter identificador se utiliza la parte de código donde se detecta el fin de la cadena para reiniciar el ciclo y guardar en una variable llamada Identificador el carácter recibido que indica R,G o B, y los datos ahora terminaran dos posiciones antes antes que el carácter “)”. El código queda de la siguiente manera:

175

if(dato[position]==41) { identificador=dato[position-1]; fin=position-1; inicio=0; position=0; } Ahora solo resta extraer los datos como en el ejemplo antes mencionado y asignarlo a la variable correspondiente dependiendo del identificador, el código queda de la siguiente manera: if(identificador=='R') { if(fin==2) pwm1=dato[1]-48; if(fin==3) pwm1=(dato[1]-48)*10+(dato[2]-48); if(fin==4) pwm1=(dato[1]-48)*100+(dato[2]-48)*10+(dato[3]-48); } if(identificador=='G') { if(fin==2) pwm2=dato[1]-48; if(fin==3) pwm2=(dato[1]-48)*10+(dato[2]-48); if(fin==4) pwm2=(dato[1]-48)*100+(dato[2]-48)*10+(dato[3]-48); } if(identificador=='B’) { if(fin==2) pwm3=dato[1]-48; if(fin==3) pwm3=(dato[1]-48)*10+(dato[2]-48); if(fin==4) pwm3=(dato[1]-48)*100+(dato[2]-48)*10+(dato[3]-48); }

176

El valor del SeekBar1 ha quedado guardado en la variable pwm1, el valor del SeekBar2 ha quedado guardado en la variable pwm2 y el valor del SeekBar3 ha quedado guardado en la variable pwm3. El código correspondiente a la tarjeta PIC USB se encuentra en la carpeta APLICACIONES PIC del CD con el nombre LED_RGB.c

MULTIPLES LECTURAS Descripción de la aplicación: Muestra la lectura de 3 canales analógicos Interfaz de usuario: 4 Label, 3 ProgressBar Hardware: Dispositivo Android, Tarjeta PIC USB, Modulo Bluetooth, 3 Potenciómetro Nombre del Proyecto: MULTIPLES_LECTURAS Package Name: MULTIPLES_LECTURAS.ANDROID Application Label: MULTIPLES LECTURAS Técnica: Envió de más de un carácter y más de una variable por bluetooth con el microcontrolador y su procesamiento en Basic4Android.

El Layout deberá quedar como se muestra a continuación:

Esta aplicación es muy similar a la desarrollada en el ejercicio PROGRESSBAR_Y_ADC en la que se lee un canal analógico de la tarjeta PIC USB y se envían varios caracteres . La diferencia es que

177

Ahora se leen 3 canales analógicos de la tarjeta por lo que se requiere enviar más de un carácter y diferenciar cada variable al enviarlas, en basic4android la recepción de los caracteres y su conversión es facilitada por medio del lenguaje por lo que los datos de entrada se pueden asignar directamente al Label y al ProgressBar, pero habrá que implementar un algoritmo para identificar cada canal analógico, esto se logra con el uso de identificadores como en el caso del ejemplo LED RGB, entonces al recibir los caracteres en el evento del Timer se tendrá que procesar la cadena y el lenguaje simplifica este proceso. Lo primero que se debe saber es el tamaño de la cadena, el identificador (siempre el penúltimo carácter), y después unir los caracteres, se utiliza un Label para recibir la cadena y 3 Label para cada canal analógico, el código correspondiente al algoritmo cuando la cantidad enviada es de un digito quedara dela siguiente manera:

El código correspondiente al algoritmo cuando la cantidad enviada es de dos dígitos quedara dela siguiente manera:

178

El código correspondiente al algoritmo cuando la cantidad enviada es de tres dígitos quedara dela siguiente manera:

Para el envío de datos con el microcontrolador se usa la instrucción printf como en el ejemplo PROGRESSBAR_Y_ADC, pero agregando el identificador en este caso se ha usado A,B y C: printf("%uA\n",ADC1/2); printf("%uB\n",ADC2/2); printf("%uC\n",ADC3/2); delay_ms(70);

La lectura del canal analógico 0 ha quedado guardado en el Label2, la lectura del canal analógico 1 ha quedado guardado en el Label3 y la lectura del canal analógico 2 ha quedado guardado en el Label4. El código correspondiente a la tarjeta PIC USB se encuentra en la carpeta APLICACIONES PIC del CD con el nombre MULTIPLES_LECTURAS.c

SERVICIO Descripción de la aplicación: Lectura continua de datos por Bluetooth Interfaz de usuario: 1 Label Hardware: Dispositivo Android, Tarjeta PIC USB, Modulo Bluetooth Nombre del Proyecto: SERVICIO Package Name: BLUETOOTHCONTINUOS.ANDROID Application Label: BLUETOOTH CONTINUOS

179 Técnica: Monitorear continuamente la recepción de datos Bluetooth (incluso con el dispositivo Bloqueado o en reposo). El Layout deberá quedar como se muestra a continuación:

El primer paso es crear un servicio, el módulo de servicio se agrega desde el menú Project como se muestra en la siguiente imagen

Aparecerá una ventana pidiendo el nombre del servicio, en este ejemplo se ha usado Notificador El servicio será el encargado de algunas funciones de la conexión Bluetooth y la recepción de datos, Por lo tanto lo primero es declarar todos los elementos necesarios para tales funciones, ya que un servicio no tiene interfaz de usuario no es posible usar un Label para guardar los caracteres recibidos por lo que se tiene que declarar una variable tipo String, el código queda de la siguiente manera:

180

El siguiente paso es inicializar el Timer y Bluetooth como en ejemplos anteriores, pero ahora en el evento Service_Create que es cuando se crea el servicio, el código quedara dela siguiente manera:

Después en el evento Service_Start el servicio se debe ejecutar por medio de la función StartForeground() especificando una notificación (no olvidar que la notificación es el modo de interactuar con el usuario), por lo tanto habrá que declarar el objeto tipo Notification y una variable Int para contar las notificaciones, el código quedara dela siguiente manera:

En el evento Tick del Timer se procesan los datos recibidos como en ejemplos anteriores y si se recibe un “2” se despliega una nueva notificación, el código queda como se muestra a continuación:

181

Por ultimo en el evento Service_Destroy que es cuando se destruye el servicio se deberá finalizar la conexión Bluetooth, el código queda de la siguiente manera:

El siguiente paso es construir la Actividad , en esta se deberá cargar el layout, y el único objeto declarado deberá ser un Label que es el del Layout, la Actividad será quien controle el inicio y cierre del servicio y la obtención de los dispositivos apareados , por lo tanto habrá que declarar 3 menú ítem, el código queda de la siguiente manera:

El evento clic del ítem Menu_conectar se encarga de obtener la lista de dispositivos y demás pasos como se vio en ejemplos anteriores, con la única diferencia de que habrá que llamar a cada variable y objeto poniendo antes el nombre del servicio seguido de punto como se muestra a continuación:

182

También en el evento Connected del Bluetooth habrá que hacer los cambios en el código mencionados anteriormente y deberá quedar como se muestra en la imagen:

183

El último paso es controlar el inicio y detención del servicio con los ítems restantes como se muestra a continuación:

Para verificar el funcionamiento cargar a la tarjeta PIC USB el archivo SERVICIO.HEX contenido en la carpeta HEX del CD, Se enviara el carácter “2” al presionar el botón BOOT.

Para correr la aplicación presionar la tecla menú del dispositivo y seleccionar Iniciar:

Aparecerá una notificación indicando que el servicio ha iniciado, luego seleccionar Conectar y elegir el dispositivo Bluetooth:

184

Aparecerá un mensaje Toast indicando que se ha establecido la conexión, y al presionar el botón BOOT de la tarjeta PIC USB aparecerá una nueva notificación:

185

AJUSTES DE MODULO BLUETOOTH Los dispositivos Bluetooth poseen un juego de instrucciones para configurar ciertos parámetros como el nombre o ID, Password, BaudRate, Modo, etc. Varían según la versión de firmware de cada fabricante, algunos necesitan cierta secuencia de activación y desactivación de pines para ingresar al modo comando, el módulo HC-06 solo necesita que se especifique los parámetros usando comandos AT a través de la UART: En el disco se incluyen 3 ejemplos que cambian el ID, Password y BaudRate del módulo bluetooth, quedando como ID=”linvor”, Password=0000 y BaudRate=115200, los archivos para descargar a la tarjeta PIC USB se encuentran en la carpeta HEX nombrados como BLUETOOTH_NAME.hex, BLUETOOTH_PASSWORD.hex y BLUETOOTH_BAUD.hex , también se proporciona el código fuente en la carpeta APLICACIONES PIC con los mismos nombres pero con extensión .c

Cambiar el nombre Para cambiar el nombre se utiliza el comando AT+NAME y se envía a través de una instrucción Printf, el comando queda como se muestra a continuación: printf("AT+NAMElinvor"); El nombre debe ir inmediatamente después del comando, por ejemplo si se desea cambiar el nombre a Android el comando quedara de la siguiente manera: printf("AT+NAMEAndroid");

Cambiar el PassWord Para cambiar el Password se utiliza el comando AT+PIN, el comando queda como se muestra a continuación: printf("AT+PIN0000"); Se requieren 4 digitos y deben ir inmediatamente después del comando, por ejemplo si se desea cambiar el Password a 2012 el comando quedara de la siguiente manera: printf("AT+PIN2012");

Cambiar el BaudRate Para cambiar el BaudRate se utiliza el comando AT+BAUD, el comando queda como se muestra a continuación: printf("AT+BAUD8");

186

Se requieren 1 digito para establecer el BaudRate y debe ir inmediatamente después del comando, para cambiar el BuadRate se tiene las siguientes opciones:

Por ejemplo si el BaudRate se quiere cambiar a 19200 el comando quedara de la siguiente manera: printf("AT+BAUD5");

187

ANDROID USB HOST + ARDUINO UNO

Desde la versión 3.0 de Android (Honeycomb) se implementó la función de USB HOST en el sistema, es posible escribir un driver en una aplicación para reconocer convertidores de SERIE a USB con chips FTDI como el integrado en un arduino uno y de esta forma establecer una interfaz.

SINGLE BOARD COMPUTERS + ANDROID

Las SBC son computadoras en una sola tarjeta y de bajo costo dotadas con salidas de video, USB, RED, entrada para periféricos, etc. El sistema operativo se instala por medio de la memoria SD, sus prestaciones son similares a los Smartphone de media gama o hasta la potencia de una tablet de gama alta, Existe una gran variedad de tarjetas ya disponibles y varias versiones de sistemas operativos como Android y Linux. Entre las SBC destaca la Raspberry pi, la Gooseberry, la Beagle Bone, etc.

188

GOOGLE ADK

Google ha desarrollado y liberado un protocolo llamado ADK (Accesory Development Kit) para el desarrollo de accesorios para dispositivos con Android 2.3.4 o superior (Gingerbread), Una tarjeta como USB HOST intercambia datos con un dispositivo Android para establecer una interfaz. Existen varias tarjetas ya disponibles como PIC24F starter kit de Microchip, Google ADK de RT, IOIO (actualizando firmware ADK), Incluso el USB HOST SHIELD para arduino. OPENCV + ANDROID

OpenCV es una libreria para el tratamiento de imagenes, puede ser integrada en dispositivos Android, para ello se requiere trabajar a un nivel más bajo es decir desarrollar aplicaciones nativas con el Android NDK. ANDROID + NFC

189

Desde la versión 4 de Android (Ice Cream Sandwich) se implementó el NFC (Near Field Communication) que es un sistema de comunicaciones de corto alcance que permite el intercambio de datos entre dispositivos, los protocolos están basados en RFID, algunas aplicaciones son el pago de servicios, identificación de objetos, intercambio de archivos, etc.

APPLE MFI

Para desarrollar accesorios o algún hardware para dispositivos de Apple el desarrollador se debe registrar en el programa MFI de Apple para acceder a la documentación de sus dispositivos, Existen varias formas de establecer interfaces con dispositivos de Apple por ejemplo a través de Wifi utilizando algún Shield para arduino o el transceiver MRF24WB0MA, también desde el conector Doc de Apple, o a través de Bluetooth utilizando alguno de los módulos compatibles que ya integren el coprocesador de Apple para vincularse como el BT-11M de Amp’ed o el PAN1321 de Panasonic.

190

Descripción: funciones bit a bit Objeto: Bit Propiedades:

Not (N como Int) como Int Devuelve el complemento bit a bit de un valor dado. Or (N1 como Int, N2 como Int) como Int Devuelve el OR bit a bit de los dos valores. ParseInt (valor como String, Radix como Int) como Int Analiza el valor como un entero usando la base especificada. Radix - debe estar entre 2 a 36. ShiftLeft (N como Int, Shift como Int) como Int Desplaza N turnos a la izquierda. Shift - número de posiciones a desplazar. ShiftRight (N como Int, Shift As Int) como Int Desplaza N turnos a la derecha. Mantiene valor del signooriginal Shift - número de posiciones a desplazar. ToBinaryString (N como Int) como String Devuelve una representación de cadena de N en base 2. ToHexString (N como Int) como String Devuelve una representación de cadena de n en base 16.

191

ToOctalString (N como Int) como String Devuelve una representación de cadena de N en base 8.

UnsignedShiftRight (N como Int, Shift como Int) como Int Desplaza N turnos a la derecha. Corre ceros en los lugares vacíos Shift - número de posiciones a desplazar. XOR (N1 como Int, N2 como Int) como Int Devuelve el XOR bit a bit de los dos valores. Descripción: Palabras clave Objeto: predefinido Propiedades: ABS (número como Double) como Double Devuelve el valor absoluto. ACos (Value como Double) como Double Devuelve el ángulo medido en radianes. ACosD (Value como Double) como Double Devuelve el ángulo medido en grados. Array Crea una matriz de dimensión única del tipo especificado. La sintaxis es: matriz como tipo (lista de valores). Ejemplo: Dim Days() As String Days() = Array As String("Domingo", "Lunes",...) ASC (Char como Char) como Int Devuelve el punto de código unicode del primer carácter o caracteres de la cadena. ASin (Value como Double) como Double Devuelve el ángulo medido en radianes. ASinD (Value como Double) como Double

192

Devuelve el ángulo medido en grados. ATan (Value como Double) como Double Devuelve el ángulo medido en radianes. ATanD (Value como Double) como Double Devuelve el ángulo medido en grados. BytesToString (Data () como Byte, StartOffset como Int, longitud como Int, CharSet como String) Decodifica las matrices de bytes dado como una cadena. Datos:la matriz de bytes. StartOffset:el primer byte para leer. Longitud: número de bytes que leer. CharSet - el nombre del juego de caracteres. Ejemplo: Dim s As String s = BytesToString (Buffer, 0, Buffer.Length, "UTF-8")

cE como Double Constante e (base de logaritmo natural). CharsToString (Chars() como Char, StartOffset como Int, Length como Int) como String Crea una nueva cadena copiando los caracteres de la matriz. Comienza desde StartOffset y el número de caracteres a copiar equivale a la longitud. Chr (UnicodeValue como Int) como Char Devuelve el carácter que está representado por el valor unicode determinado. Continue Detiene la ejecución de la iteración actual y continúa con el siguiente. Cos (Radians como Double) como Double Calcula la función trigonométrica coseno. Ángulo medido en radianes. CosD (Degrees como Double) como Double Calcula la función trigonométrica coseno. Ángulo medido en grados.

193

cPI como Double Constante PI.

CRLF como String Carácter de nueva línea. El valor de chr (13). Density como Float Devuelve la escala del dispositivo, que es DPI / 160. (DPI significa puntos por pulgada). Dim Declara una variable. DipToCurrent (Length como Int) como Int Escala el valor, que representa una longitud específica en un dispositivo de densidad predeterminada (densidad = 1.0), al dispositivo actual. Por ejemplo, el siguiente código establece el valor de ancho de este botón para tener el mismo tamaño físico en todos los dispositivos. Button1.Width = DipToCurrent (100) Exit Se cierra el bucle más interno. ExitApplication Inmediatamente termina la aplicación y detiene el proceso. La mayoría de las aplicaciones no usan este método y prefieren Activity.Finish que permite que el sistema operativo decida cuando asesinar el proceso. False como Boolean File como File Metodos relacionados con archivos. Floor (Number Double) como Double Devuelve el Double más grande que es menor o igual al número especificado y es igual a un entero.

194 For Sintaxis: For variable = valor1 To valor2

GetDeviceLayoutValues como LayoutValues Devuelve los valores de Layout del dispositivo Ejemplo: Log(GetDeviceLayoutValues) GetType (object como Object) como String Devuelve una cadena que representa el tipo del objeto java. If Sintaxis: If condición then Declaración Else Declaración End If InputList (Items como List, Title como String, CheckedItem como Int) como Int Muestra un cuadro de diálogo modal con una lista de elementos y RadioButton. Pulsando sobre un elemento se cerrará el cuadro de diálogo. Devuelve el índice del elemento seleccionado o DialogResponse.Cancel si el usuario presiona el botón Back. List - elementos para mostrar. Title - Título del diálogo. CheckedItem - el índice del elemento que será seleccionado por default. Usar -1 si ningún elemento debe ser preseleccionado. InputMultiList (elementos como lista, título como String) como List Muestra un cuadro de diálogo modal con una lista de elementos y CheckBox. El usuario puede seleccionar varios elementos. El cuadro de diálogo se cierra pulsando sobre el botón OK Devuelve una lista con los índices de los elementos seleccionados. La lista está ordenada. Devuelve una lista vacía si el usuario ha presionado la tecla back. IsBackgroundTaskRunning (ContainerObject como Object, TaskId como Int) como Boolean Comprueba si una tarea en segundo plano, presentada por el objeto contenedor y con el id especificado, se está ejecutando.

195

IsNumber (Text como String) como Boolean Comprueba si la cadena especificada puede analizarse de forma segura como un número.

LastException como Exception Devuelve la última excepción que fue capturada (si existe tal excepción). LoadBitmap (Dir como String, FileName As String) como Bitmap Carga el Bitmap. Tener en cuenta que el sistema de archivos Android distingue mayúsculas de minúsculas. Se debe considerar el uso de LoadBitmapSample si el tamaño de la imagen es grande. El tamaño real del archivo no es relevante, normalmente se almacenan imágenes comprimidas. Ejemplo: Activity.SetBackgroundImage (LoadBitmap (File.DirAssets,"SomeFile.jpg")) LoadBitmapSample (Dir como String, FileNamecomo String, MaxWidth como Int, MaxHeight como Int) como Bitmap Carga el mapa de bits con el tamaño especificado. Ejemplo: Activity.SetBackgroundImage (LoadBitmapSample (File.DirAssets, "SomeFile.jpg", Activity.Width, Activity.Height)) Log (MessageAs String) Registra un mensaje. El registro puede verse en la pestaña LogCat. Logarithm (Number como Double, Base como Double) como Double Max (Number1 como Double, Number2 como Double) como Double Devuelve el número más grande entre los dos números. Min (Number1 como Double, Number2 como Double) como Double Devuelve el número menor entre los dos números. MsgBox (Message como String, Title como String) Muestra un cuadro de mensaje modal con el mensaje y el título especificado. El cuadro de diálogo mostrará un botón OK. Ejemplo: MsgBox ("Hola mundo", "Este es el título")

196

Msgbox2 (Message como String, Title como String, Positive como String, Cancel como String, Negative como String, Icon como android.graphics.Bitmap) como Int Muestra un cuadro de mensaje modal con el mensaje y el título especificado. Message - el mensaje del cuadro de diálogo. Títle - el título del cuadro de diálogo. Positive - el texto a mostrar para el botón "positivo". Usar "" si no desea mostrar el botón. Cancel - el texto a mostrar para el botón "cancelar". Usar "" si no desea mostrar el botón. Negative - el texto a mostrar para el botón "negativo". Usar "" si no desea mostrar el botón. Icon - un mapa de bits que se dibujará cerca del título. Usar Null si no desea mostrar un icono. Devuelve uno de los valores de DialogResponse. Ejemplo: Dim resultado AsInt resultado = Msgbox2 ("Este es el mensaje", "Este es el título", "positivo", "", "negativo", LoadBitmap (File.DirAssets, "smiley.gif")) If resultado = DialogResponse.Positive Then... Not (Value como Boolean) como Boolean Invierte el valor de un booleano. NULL como Object PerXToCurrent (Percentage como Float) como Int Devuelve el tamaño real de determinado porcentaje de la anchura de la actividad. Ejemplo: Button1.Width = PerXToCurrent(50) ' Button1.Width = 50% * Activity.Width PerYToCurrent (porcentaje como Float) como Int Devuelve el tamaño real de determinado porcentaje de la altura de la actividad. Ejemplo: Button1.Height = PerYToCurrent(50) ' Button1.Height = 50% * Activity.Height Power (Base como Double, Exponent como Double) como Double Devuelve el valor Base elevado a la potencia Exponent ProgressDialogHide Esconde un cuadro de diálogo de progreso visible.

197 ProgressDialogShow (Text como String) Muestra un cuadro de diálogo con una barra giratoria circular y el texto especificado.

A diferencia de los métodos de Msgbox e InputList, el código no se bloqueará. Se debe llamar a ProgressDialogHide para quitar el cuadro de diálogo. El cuadro de diálogo también se eliminará si el usuario presiona la tecla atrás. ProgressDialogShow2 (Text como String, Cancelable como Boolean) Muestra un cuadro de diálogo con una barra giratoria circular y el texto especificado. A diferencia de los métodos de Msgbox y InputList, el código no se bloqueará. Se debe llamar a ProgressDialogHide para quitar el cuadro de diálogo. Cancelable - si el usuario puede descartar el cuadro de diálogo presionando la tecla atrás. Quotecomo String Carácter Quote. El valor de chr (34). Return Devuelve un valor especificado Rnd (Min como Int, Max como Int) como Int Devuelve un entero aleatorio entre Min (inclusive) y Max (exclusivo). Round(Number como Double) como Long Devuelve el Long más cercano al número dado. Round2 (Number como Double, DecimalPlaces como Int) como Double Redondea el número determinado y deja el número especificado de dígitos fraccionarios. Select Compara un valor único para varios valores. Ejemplo: Dim valor As Int valor = 7 Select valor Case 1: Log("un") Case 2, 4, 6, 8:Log("par") Case 3, 5, 7, 9:Log("impar más grande que uno")

198 Case Else Log("mayor que 9") End Select

Sin (Radians como Double) como Double Calcula la función trigonométrica seno. Ángulo medido en radianes. SinD (Radians como Double) como Double Calcula la función trigonométrica seno. Ángulo medido en grados.

Sqrt(Value como Double) como Double Devuelve la raíz cuadrada positiva. StartActivity (Activity como Object) Inicia una actividad o trae al primer plano si ya existe. La actividad puede ser una cadena con el nombre de la actividad de destino o puede ser la propia actividad. Después de esta llamada se interrumpirá la actividad actual y se reanudará la actividad de destino. Tab como String Carácter de tabulación. Tan (Radians como Double) como Double Calcula la tangente trigonométrica. Ángulo medido en radianes. TanD (Degrees como Double) como Double Calcula la tangente trigonométrica. Ángulo medido en grados. ToastMessageShow (Message como String, LongDuration como Boolean) Muestra un mensaje que se desvanece automáticamente. Message - el mensaje de texto a mostrar. LongDuration - si es true muestra el mensaje durante un largo período, de lo contrario muestra el mensaje durante un Período corto. True como Boolean While

199 Bucle mientras la condición es verdadera. Sintaxis: Do While condición ... LOOP Descripción: valores relacionados con la pantalla Objeto: Layout Values Propiedades: Heightcomo Int La altura de la pantalla (píxeles). Escale como Float El valor de escala del dispositivo que es igual a DPI/ 160. Para la mayoría de los dispositivos, el valor será 1 o 1.5 (alta resolución). toString como String Widthcomo Int La anchura de la pantalla (píxeles). Descripción: cadenas Objeto: String Propiedades: CharAt (Index como Int) como Char Devuelve el carácter en el índice especificado. CompareTo (Other como String) como Int Lexicográficamente compara las dos cadenas. Devuelve un valor menor que 0, si la cadena actual precede a otro. Devuelve 0 si las cadenas son iguales. Devuelve un valor mayor que 0 si la cadena actual viene después de otra. Notar que mayúsculas preceden a minúsculas. Ejemplos: "abc".CompareTo("da") ' < 0 "abc".CompareTo("Abc") ' > 0

200 "abc".CompareTo("abca")' < 0 EndsWith (Suffix como String) como Boolean Devuelve true si esta cadena termina con el sufijo determinado. EqualsIgnoreCase (other como String) como Boolean Devuelve true si dos cadenas son iguales ignorando su caso. GetBytes (Charset como cadena) como Byte() Codifica la cadena en una nueva matriz de bytes. Ejemplo: Dim Data() As Byte Datos = "Una cadena".GetBytes("UTF8") Length como Int Devuelve la longitud de la cadena. Replace (Target como String, Replacement como String) como String Devuelve una nueva cadena resultante de la sustitución de todas las apariciones de destino con Reemplazo. StartsWith (Prefix como String) como Boolean Devuelve true si esta cadena comienza con el prefijo especificado. SubString (BeginIndex como Int)como String Devuelve una nueva cadena que es una subcadena de la cadena original. La nueva cadena incluirá el carácter BeginIndex y se extenderá hasta el final de la cadena. Ejemplo: "012345".SubString(2) ' devuelve "2345" ToLowerCase como String Devuelve una nueva cadena en minúscula ToUpperCase como String Devuelve una nueva cadena en mayúscula.

201

http://www.basic4ppc.com/android/documentation.html http://www.basic4ppc.com/forum/index.php http://developer.android.com/index.html https://github.com/ytai/ioio/wiki http://www.pinguino.cc/ http://www.neoteo.com/modulo-bluetooth-hc-06-android http://romotive.com/ http://android.serverbox.ch/ http://robots-everywhere.com/re_wiki/index.php?title=Serial_on_Android_using_the_audio_port http://developer.android.com/tools/adk/index.html http://webdelcire.com/wordpress/archives/1045 http://appinventor.mit.edu/