Guia de Aprendizaje

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. Se inició una actividad diferente. 2. Se presionó el botón de Home.

3. Un cambio de configuración levantada (se rota el dispositivo por ejemplo). 4. 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


CheckedChange cuando el CheckBox cambia de estado


Enabled habilita o deshabilita el CheckBox

Text establece el texto del CheckBox

Visible esconde o muestra el CheckBox


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.


TextChanged cuando el usuario toca el EditText

EnterPressed cuando se presiona la tecla enter


Enabled habilita o deshabilita el EditText

Text establece el texto del EditText

Visible esconde o muestra el EditText


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.


Clic cuando el usuario toca el ImageView


Enabled habilita o deshabilita el ImageView

Visible esconde o muestra el ImageView


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.


Click cuando el usuario toca el Label

13


Enabled habilita o deshabilita el Label

Visible esconde o muestra el Label


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


ItemClick cuando el usuario toca algún elemento del ListView


Enabled habilita o deshabilita el ListView

Visible esconde o muestra el ListView


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.


Touch cuando el usuario toca el Panel (coordenadas)


Enabled habilita o deshabilita el Panel

Visible esconde o muestra el Panel


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.


No tiene eventos


15

Enabled habilita o deshabilita el ProgressBar

Visible esconde o muestra el ProgressBar


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.


CheckedChange cuando el RadioButton cambia de estado


Enabled habilita o deshabilita el RadioButton

Text establece el texto del RadioButton

Visible esconde o muestra el RadioButton


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


ValueChanged cuando el SeekBar cambia de posición


Enabled habilita o deshabilita el ProgressBar

Visible esconde o muestra el ProgressBar


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


ItemClick cuando el usuario toca algún elemento del Spinner


Enabled habilita o deshabilita el Spinner

Visible esconde o muestra el Spinner


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.


TabChanged cuando el usuario toca una pestaña diferente


Enabled habilita o deshabilita el TabHost

Visible esconde o muestra el TabHost


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.


CheckedChange cuando el usuario toca el ToggleButton

18


Enabled habilita o deshabilita el ToggleButton

Visible esconde o muestra el ToggleButton


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.


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


Enabled habilita o deshabilita el WebView

Visible esconde o muestra el WebView


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

(mW)

Potencia máxima permitida

(dBm)

Rango

(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 Ancho de banda

Versión 1.2 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


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





37


Figura 8.- JAVA JDK encontrada


Figura 9.- Ruta de instalación

38


Figura 10.- Comienzo de la instalación


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





45

Marcar aceptar los términos y hacer clic en siguiente

Figura 21.- Términos del software


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 Genera un nuevo proyecto. Open Source Carga un proyecto.

Save Guarda el proyecto actual. Export as Zip Exporta todo el proyecto en un archivo Zip. Page Setup Configuración de las páginas a imprimir Print Preview Muestra una vista previa de impresión Print 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 Agrega un nuevo módulo

Add Existing Module Añadir un módulo existente Change Module Name Cambia el nombre del módulo Remove Module Quita el módulo actual Hide Module Oculta el módulo actual Activity Properties Propiedades de la actividad, explicado abajo Choose Icon Elige un icono para la aplicación.

Package Name Cambia el nombre del paquete.

Application Label Cambia el nombre de la aplicación.

57

Application Versión Cambia la versión de la aplicación. Can internal storage La aplicación se instala en almacenamiento externo

Orientations Supported Orientaciones compatibles, explicado abajo. Compile & Run Diferentes modos de compilación. Include Debug Information Incluir Información de depuración Attach to Debbugger 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 Opciones de IDE B4A Bridge Herramienta de depuración B4A Clean Files Folder Limpiar archivos sin utilizar Clean Project Limpiar proyecto Run AVD Manager Ejecutar el administrador de AVD Configure Paths Configurar rutas Restart ADB Server Reiniciar el servidor ADB Private Sign Key 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 Se abre un nuevo diseño de vacío. Open Abre un diseño existente

Save Guarda el diseño actual. Save As 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 agrega un botón

CheckBox agrega una casilla de verificación EditText agrega una caja de texto ImageView agrega una caja de imagen Label agrega una etiqueta ListView agrega un control tipo lista Panel agrega un contenedor

ProgressBar agrega una barra de progreso RadioButton agrega un radio botón

ScrollView agrega un vista scroll SeekBar agrega una barra deslizable Spinner agrega un combo TabHost agrega un tabulador ToggleButton agrega un botón toggle WebView 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


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)


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


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


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



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


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



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


Nombre del Proyecto: SEEKBAR




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


Nombre del Proyecto: ProgressBar




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


81

Nombre del Proyecto: RADIOBUTTON




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


Nombre del Proyecto: CHECKBOX




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


Nombre del Proyecto: ANIMATION




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



Nombre del Proyecto: TTS



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



Nombre del Proyecto: VOICE RECOGNITION



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


Nombre del Proyecto: TIMER



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.


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



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.


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


Hardware: Dispositivo Android, algún objeto metálico o inductivo

Nombre del Proyecto: MAGNETOMETER



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.


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





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:


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


Nombre del Proyecto: ADVANCED CAMERA



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


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


Hardware: Dispositivo Android, código de barras o QR

Nombre del Proyecto: ADVANCED CAMERA

105



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


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


Nombre del Proyecto: ACELEROMETER



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.


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:





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:


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


Nombre del Proyecto: ACELEROMETER



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



Nombre del Proyecto: NOTIFICATION


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



Nombre del Proyecto: MEDIAPLAYER



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


Nombre del Proyecto: RTC



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



Nombre del Proyecto: GPS



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

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


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


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:



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


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




129


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.



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



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



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


Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta PIC USB

Nombre del Proyecto: BLUETOOTH RX



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.


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.



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



Para utilizar la tarjeta IOIO en Basic4android se deben incluir las librerías IOIO y IOIOlib al

proyecto.


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


Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta IOIO, adaptador para IOIO,

Potenciómetro

Nombre del Proyecto: IOIO ANALOG


148


.


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


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



151

.


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


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


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



158



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


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-Izquierda-

Derecha-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. Controlar los movimientos del robot a través del reconocimiento de voz

2. Buscar metales por medio del magnetómetro

3. Evadir obstáculos por medio del sensor de proximidad del teléfono

4. Clasificar objetos por medio de códigos QR

5. Mostrar la ubicación del Robot en google usando el GPS.

6. Formar una red de 2 robots para implementar una coreografía de baile simple.

7. 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


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:


{

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


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 Carácter en ASCII

s Cadena

u Entero sin signo en formato decimal

d Entero con signo en formato decimal

Lu Entero sin signo de 16 bit en formato decimal

Ld Entero con signo de 16 bit en formato decimal

x Entero en formato hexadecimal (minúsculas)

X Entero en formato hexadecimal (mayúsculas)

f Flotante con punto decimal

g Flotante redondeado

e 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


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


{

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)


}

if(identificador=='B’)

{

if(fin==2)

pwm3=dato[1]-48;

if(fin==3)

pwm3=(dato[1]-48)*10+(dato[2]-48);

if(fin==4)


}

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.


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


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 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 signo original 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


ASinD (Value como Double) como Double

192


ATan (Value como Double) como Double


ATanD (Value como Double) como Double


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, FileName como 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 (Message As 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 As Int 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.

Quote como 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:

Height como 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

Width como 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/

Guia de Aprendizaje

Documents

Transcript of Guia de Aprendizaje