1
2
El presente trabajo es una guía de aprendizaje para el desarrollo de aplicaciones Android y
construcción de circuitos de interfaz con el mundo real para su posterior aplicación en robótica
móvil. En esta guía contiene el resultado de una investigación de 6 meses de residencia
profesional recopilando y probando diferentes métodos, software, pruebas y conclusiones
obtenidas a lo largo de este periodo.
Se explican los conceptos básicos para familiarizarse con el sistema Android y se desarrollaran
aplicaciones básicas y sencillas hasta llegar a las aplicaciones de interfaz con hardware externo que
será construido por el lector. Se proporcionan los códigos fuente, esquemáticos, software y demás
recursos contenidos en el CD como medio de apoyo.
Se han construido dos interfaces para experimentar con Android a través de bluetooth y USB que
serán utilizados en las prácticas de igual forma se ha diseñado un robot que servirá de modelo
para futuros proyectos y entender mejor los conocimientos adquiridos.
Se requieren nociones de programación en algún lenguaje y también el uso de microcontroladores
o alguna tarjeta de desarrollo como arduino o similar.
Desarrollos por José Luis Ku Uc
Asesorado por Dr. José Ramón Atoche Enseñat
Departamento de Ingeniería Eléctrica y Electrónica
Agosto de 2012
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
Principales eventos:
CheckedChange cuando el CheckBox cambia de estado
Principales propiedades comunes:
Enabled habilita o deshabilita el CheckBox
Text establece el texto del CheckBox
Visible esconde o muestra el CheckBox
Principales propiedades especiales:
Checked establece si estará marcado por default (se utiliza también para saber si esta
seleccionado)
3. EditText
El EditText (Texto Editable) es un View utilizado como entrada de caracteres al hacer clic en el
aparece el teclado de Android para introducir datos generalmente no se usan eventos.
Principales eventos:
TextChanged cuando el usuario toca el EditText
EnterPressed cuando se presiona la tecla enter
Principales propiedades comunes:
Enabled habilita o deshabilita el EditText
Text establece el texto del EditText
Visible esconde o muestra el EditText
Principales propiedades especiales:
PassWord establece si se usa el modo contraseña
SingleLine establece si se usa el modo de solo una línea
12
InputType elige el tipo de entrada (letras, números, etc.)
4. ImageView
El ImageView (Vista de imagen) es un View muy común y utilizado para desplegar imágenes
también puede ser utilizado como botón.
Principales eventos:
Clic cuando el usuario toca el ImageView
Principales propiedades comunes:
Enabled habilita o deshabilita el ImageView
Visible esconde o muestra el ImageView
Principales propiedades especiales:
ImageFile indica la imagen que contendrá el ImageView
Gravity establece la forma de contener la imagen (centro, estrecho, etc.)
5. Label
El Label (Etiqueta) es un View muy común y utilizado para desplegar texto pero al igual que el
ImageView puede ser utilizado como botón.
Principales eventos:
Click cuando el usuario toca el Label
13
Principales propiedades comunes:
Enabled habilita o deshabilita el Label
Visible esconde o muestra el Label
Principales propiedades especiales:
Text Style configura el tipo de fuente, tamaño, color, etc.
Drawable establece el estilo grafico del Label
6. ListView
El ListView (Vista de lista) es un View utilizado para presentar una lista de elementos
seleccionables llamados ítems. Los elementos de la lista se construyen desde código
Principales eventos:
ItemClick cuando el usuario toca algún elemento del ListView
Principales propiedades comunes:
Enabled habilita o deshabilita el ListView
Visible esconde o muestra el ListView
Principales propiedades especiales:
Drawable establece el estilo grafico del ListView
14
FastScroollEnabled Habilita o deshabilita la barra de desplazamiento rápido cuando se desliza el
ListView
7. Panel
El Panel (Tablero) es un View utilizado para agrupar Views.
Principales eventos:
Touch cuando el usuario toca el Panel (coordenadas)
Principales propiedades comunes:
Enabled habilita o deshabilita el Panel
Visible esconde o muestra el Panel
Principales propiedades especiales:
Drawable establece el estilo grafico del Panel
8. ProgressBar
El ProgressBar (Barra de avance) es un View utilizado para mostrar el avance de alguna operación
o alguna cantidad en forma de barra como por ejemplo en una descarga.
Principales eventos:
No tiene eventos
Principales propiedades comunes:
15
Enabled habilita o deshabilita el ProgressBar
Visible esconde o muestra el ProgressBar
Principales propiedades especiales:
Indeterminate establece el estilo grafico del ProgressBar
Progress establece el avance del ProgressBar (accesible solo desde código)
9. RadioButton
El RadioButton (Radio-Botón) es un View utilizado para marcar o seleccionar opciones cuando hay
varios RadioButton existe una agrupación si están dentro de un panel solo se puede seleccionar
uno si existe otro fuera del panel también se puede seleccionar pero no se podrá seleccionar otro
que este en el mismo grupo que este último. Por ejemplo es útil cuando selecciona un dispositivo
bluetooth para emparejarse ya que solo se puede emparejar con uno a la vez.
Principales eventos:
CheckedChange cuando el RadioButton cambia de estado
Principales propiedades comunes:
Enabled habilita o deshabilita el RadioButton
Text establece el texto del RadioButton
Visible esconde o muestra el RadioButton
Principales propiedades especiales:
Checked establece si estará marcado por defualt (se utiliza también para saber si esta
seleccionado)
10. SeekBar
16
El SeekBar (Barra de búsqueda) es un View deslizable para controlar numéricamente una acción,
por ejemplo para cambiar el brillo de la pantalla o el volumen de audio. Es lo contrario al
ProgressBar
Principales eventos:
ValueChanged cuando el SeekBar cambia de posición
Principales propiedades comunes:
Enabled habilita o deshabilita el ProgressBar
Visible esconde o muestra el ProgressBar
Principales propiedades especiales:
MaxValue establece el valor máximo que puede tomar (tipo entero)
Value establece el avance del SeekBar (se usa también para saber la posición)
11. Spinner
El Spinner (Hilandero) es un View tipo lista conocido en el ambiente Visual Basic como ComboBox
tiene un funcionamiento similar al ListView, pero a diferencia de este la lista de ítems se despliega
hasta hacer tocar la flecha. Los elementos de la lista se construyen desde código
Principales eventos:
ItemClick cuando el usuario toca algún elemento del Spinner
Principales propiedades comunes:
Enabled habilita o deshabilita el Spinner
Visible esconde o muestra el Spinner
Principales propiedades especiales:
Prompt establece el título que aparecerá cuando la lista de ítems se despliega (Spinner abierto)
17
12. TabHost
El TabHost (Huésped de pestañas) es un View utilizado para mostrar varias pestañas cada una con
su propia interfaz de usuario. Es útil cuando la cantidad de información que se quiere mostrar no
alcanza en la pantalla. Cada pestaña requiere de un Layout.
Principales eventos:
TabChanged cuando el usuario toca una pestaña diferente
Principales propiedades comunes:
Enabled habilita o deshabilita el TabHost
Visible esconde o muestra el TabHost
Principales propiedades especiales:
Solo son accesibles desde código
13. ToggleButton
El ToggleButton (botón conmutador) es un View similar al Button tradicional pero con la
característica que cuando se toca hace un cambio de estado (como un CheckBox). Cuenta también
con un gráfico para indicar su estado.
Principales eventos:
CheckedChange cuando el usuario toca el ToggleButton
18
Principales propiedades comunes:
Enabled habilita o deshabilita el ToggleButton
Visible esconde o muestra el ToggleButton
Principales propiedades especiales:
Checked establece el estado por defualt (se utiliza también para saber el estado)
Text On establece el texto a mostrar cuando el estado del ToggleButton es verdadero
Text Off establece el texto a mostrar cuando el estado del ToggleButton es falso
14. WebView
El WebView (Vista Web) es un View usado para funciones de navegación como mostrar una
página de internet, permite también el uso de JavaScript.
Principales eventos:
PageFinished este evento se ejecuta después de que la página es cargada por completo
Override Url este evento se ejecuta antes de cargar cualquier Url
Principales propiedades comunes:
Enabled habilita o deshabilita el WebView
Visible esconde o muestra el WebView
Principales propiedades especiales:
19
JavaScriptEnabled habilita o deshabilita el uso de JavaScript
ZoomEnabled habilita o deshabilita el zoom en el WebView
Cuando el usuario ha terminado de diseñar su interfaz de usuario el resultado final que contiene
todos los Views agregados al diseño y las configuraciones establecidas es llamado Layout. El diseño
de un Layout puede realizarse desde la herramienta Designer para facilitar el proceso, a partir de
este punto se cuenta con dos opciones: la primera es crear el Layout con el emulador y la segunda
desde el dispositivo conectado a la PC por USB o en red.
A continuación se describen las partes más importantes en el sistema operativo con respecto a la
pantalla de usuario:
20
LA PANTALLA PRINCIPAL
1. Status Bar (barra de estado) en esta área se despliegan los iconos indicadores de batería,
red, hora, etc. Las notificaciones también aparecen en esta área.
2. Widgets son pequeñas aplicaciones en pantalla con una interfaz de usuario limitada y
reducida.
3. Lanzador de aplicaciones al tocar el icono se mostraran todas las aplicaciones instaladas
(este es un claro ejemplo de cambio de activity ya que se cambia de pantalla)
4. Dock en esta área se aloja el icono lanzador de aplicaciones y otros accesos directos.
5. Home esta es la pantalla principal
EL DISEÑADOR EN EL EMULADOR
Para un layout existen dos orientaciones de pantalla Portrait y Landscape presionando Ctrl + F11
cambiara la orientación del emulador para poder diseñar la interfaz de usuario.
Figura 2.- Orientación de pantalla Landscape (izquierda) y Portrait (Derecha)
Cuando el usuario ha terminado de diseñar su interfaz de usuario el siguiente paso es guardar el
Layout con un nombre sin usar espacios ni caracteres especiales.
21
LOS INTENTS Y SERVICIES
Aun con todas las funciones básicas e interfaces de usuario no es suficiente para desarrollar
potentes aplicaciones como sucede en el caso de la programación de microcontroladores o en los
programas de computadora ya que en estos es necesario el uso de interrupciones para hacer
funciones multitarea y aprovechar al máximo los recursos. Android proporciona ciertas funciones
que complementan las aplicaciones y representan la mayor parte de la potencialidad del sistema
operativo los Intents y los Servicies.
Los Intent son un medio para comunicar aplicaciones entre sí de esta forma intercambian
información en un formato único con ciertos parámetros. Por ejemplo cuando se toca un vínculo
que está en una aplicación, emerge una ventana donde presenta las aplicaciones que pueden
mostrar la página (navegadores como opera mini o la aplicación de internet), en ese momento se
ejecuta un Intent que pasara como parámetros a la aplicación seleccionada la Url de la página a
visitar.
Los Servicies se definieron anteriormente como código que se ejecuta en segundo plano y no tiene
interfaz de usuario. Anteriormente se explicó el ciclo de vida de las actividades y estas se
destruyen al presionar la tecla back, Los servicios a diferencia pueden estarse ejecutando sin
necesidad de estar en alguna aplicación y se puede estar haciendo otras tareas. Por ejemplo el
usuario puede estar navegando, jugando o escribiendo un mensaje de texto, incluso cuando el
teléfono está en reposo. En algún momento el sistema avisara al usuario que ha recibido un nuevo
correo electrónico, o tiene una notificación de Facebook, Esto es posible gracias a los servicios ya q
no es necesario estar en la aplicación de Facebook para recibir una notificación, Sin embargo al
tocar la notificación en la barra de estado se lanzara una aplicación. Las notificaciones de Android
son el medio en que los servicios interactúan con el usuario y con las aplicaciones.
CONFIGURACION DE LAS APLICACIONES
Las aplicaciones en Android requieren de configuraciones especiales para ser distribuidas, en estas
configuraciones se debe especificar la versión de Android a utilizar, nombre del paquete,
orientación de pantalla soportada, permisos, firmas, versión, icono, etc. Basic4android ha
simplificado esta tarea ya que por ejemplo al incluir una librería en nuestro proyecto
automáticamente los permisos se agregan al archivo de configuración conocido como Android
Manifest. Estas se pueden configurar desde el menú Project a continuación se explicara las
configuraciones necesarias para las aplicaciones desarrolladas en Basic4Android.
22
Full Screen
Marcando esta opción la barra de estado permanecerá oculta y la aplicación ocupara toda la
pantalla
Include Title
Marcando esta opción se muestra el título de la aplicación
Choose Icon
Por medio de esta opción se selecciona el icono usado por la aplicación puede ser un archivo de
imagen BMP, JPG, GIF, PNG.
Package Name
Es un nombre en formato algo.algo por ejemplo miaplicacion.android, es un identificador único
para la aplicación, no puede contener espacios ni caracteres especiales.
23
Application Label
Es el título que parece debajo del icono de la aplicación se permite el uso de espacios
Versión
Se requiere un número en entero para indicar la versión de la aplicación y una cadena de texto por
ejemplo:
Version Code: 1, Version String: Beta
Can Install To External Storage
Seleccionando esta opción la aplicación se instalara en el almacenamiento externo (memoria SD)
útil en dispositivos con poca memoria interna. Es importante no usar esta opción si la aplicación
proporciona Widgets y utiliza Servicies.
24
Orientations Supported
Selecciona la orientación de la aplicación puede ser Portrait (Retrato), Landscape (Paisaje) y Both
(Ambos).
Si se elige Portrait permanecerá así a pesar de rotar el dispositivo. Si se elige Landscape
permanecerá así a pesar de rotar el dispositivo. Si se elige Both la aplicación Rotara si el dispositivo
rota y si tiene activada la rotación automática.
CONCEPTOS DE ELECTRONICA
MICROCONTROLADORES
Un Microcontrolador es un circuito integrado (Chip) programable, en otras palabras es una
pequeña computadora que necesita de hardware externo de entrada y salida. Las entradas
pueden ser: sensores, interruptores, teclados, etc. Las salidas pueden ser: LED’s, Pantallas,
Relevadores, Zumbadores, etc. Por medio de un software se diseña el programa para el
Microcontrolador en algún lenguaje como Basic, C, ensamblador, etc. En la actualidad los
microcontroladores son la herramienta fundamental para el desarrollo científico y tecnológico,
saber sobre estos dispositivos electrónicos es muy importante ya que se encuentran en la mayoría
de las cosas desde un juguete hasta un transbordador espacial.
Actualmente existen herramientas generales de hardware y software que facilitan el diseño con
microcontroladores, reducen el tiempo, la complejidad, el costo, etc. Entre ellos destacan
software de alto nivel como CCS, PIC BASIC, PROTON, MIKROC, etc. Pero existen además
herramientas específicas que facilitan aún más el proceso de desarrollo tal es el caso de
plataformas como Arduino, Pingüino, Basic Stamp, Picaxe, etc.
25
MICROCONTROLADORES PIC
Los PIC son una familia de microcontroladores fabricados por Microchip Technology Inc. Para
transferir el código de un ordenador al PIC normalmente se usa un dispositivo llamado
programador. Microchip proporciona un entorno de desarrollo freeware llamado MPLAB que
incluye un simulador software y un ensamblador. Otras empresas desarrollan
compiladores C y BASIC.
ARDUINO
Arduino es una plataforma de electrónica abierta para la creación de prototipos basada en
software y hardware flexibles y fáciles de usar. Se creó para artistas, diseñadores, aficionados y
cualquiera interesado en crear entornos u objetos interactivos.
Arduino puede tomar información del entorno a través de sus pines de entrada de toda una gama
de sensores y puede afectar aquello que le rodea controlando luces, motores y otros actuadores.
El microcontrolador en la placa Arduino se programa mediante el lenguaje de programación
Arduino (basado en Wiring) y el entorno de desarrollo Arduino (basado en Processing). Los
proyectos hechos con Arduino pueden ejecutarse sin necesidad de conectar a un ordenador, si
bien tienen la posibilidad de hacerlo y comunicar con diferentes tipos de software (p.ej. Flash,
Processing, MaxMSP).
Las placas pueden ser hechas a mano o compradas montadas de fábrica; el software puede ser
descargado de forma gratuita
26
PINGÜINO
Pingüino es una plataforma de desarrollo similar a Arduino, pero basada en microcontrladores PIC.
Es compatible con microcontroladores de 8 y de 32 bits, todos con USB integrado (sin chip FTDI).
Pingüino viene con un cargador de arranque USB. Este pequeño programa que se ejecuta dentro
del microcontrolador es responsable de transferir la aplicación desde la PC a la memoria del
microcontrolador.
Las tarjetas Pingüino se pueden utilizar de diferentes maneras dependiendo de las habilidades del
usuario:
Con el IDE Pingüino y el Lenguaje Pingüino (basado en C y casi compatible con el lenguaje Arduino)
con © Microchip MPLAB X IDE ©. Pingüino es un entorno de desarrollo integrado (IDE), que da a
todos la capacidad de escribir, compilar y cargar programas en una tarjeta Pingüino.
El lenguaje Pingüino es casi compatible con el lenguaje Arduino, Bibliotecas y Shields.
PICAXE
El sistema PICAXE es un sistema de programación de microcontroladores poderoso, pero muy
económico, diseñado para el uso educativo y aficionado de los microcontroladores
Una de las características únicas del sistema PICAXE es que los programas pueden descargarse directamente al microcontrolador mediante un cable conectado al mismo, por lo tanto no se requiere el uso de equipos programadores/eliminadores de alto costo. Además, el software es fácil de utilizar y gratis; por lo tanto los estudiantes pueden trabajar sus proyectos utilizando el sistema de programación completo en casa.
Los programas pueden crearse ya sea gráficamente utilizando organigramas, o programando utilizando un lenguaje BASIC sencillo incluido en el software.
27
PERIFERICOS
En informática, se denomina periféricos a los aparatos y/o dispositivos auxiliares e independientes
conectados al CPU de una computadora.
Se consideran periféricos tanto a las unidades o dispositivos a través de los cuales
la computadora se comunica con el mundo exterior y que permitan realizar operaciones de
entrada/salida. En los microcontroladores los periféricos realizan la misma tarea, pero están
implementados dentro del mismo chip.
Los periféricos pueden clasificarse en 3 categorías principales:
Periféricos de entrada: captan información del mundo exterior.
Periféricos de salida: son dispositivos que muestran o proyectan información hacia el mundo
exterior
Periféricos de entrada/salida (E/S): sirven básicamente para la comunicación con el medio
externo.
Entre los periféricos más comunes implementados en los microcontroladores se pueden
encontrar:
ADC’s: Convertidores Analógico a Digital, generalmente usado para obtener la información de
sensores.
PWM’s: Moduladores de ancho de pulso, generalmente usado para controlar la intensidad y
velocidad de ciertas cargas como focos y motores.
DAC’s: Convertidores de Digital a Analógico, es un dispositivo para convertir datos digitales en
señales de corriente o de tensión analógica.
UART: Transmisor-Receptor Asíncrono Universal, es un medio para la comunicación con otros
microcontroladores o dispositivos.
SENSORES Y ACTUADORES
Un sensor es un dispositivo capaz de detectar magnitudes físicas o químicas y transformarlas en
magnitudes eléctricas, Los sensores trasladan la información desde el mundo real al mundo
abstracto de los microcontroladores. Existen diferentes tipos de sensores pueden ser mecánicos,
ópticos, sónicos, magnéticos, piezoeléctricos, etc. Estos dispositivos proporcionan información del
mundo real como la temperatura, la presión, la iluminación, aceleración, fuerza, etc.
28
Un actuador es un dispositivo capaz de convertir energía hidráulica, neumática o eléctrica en la
activación de un proceso con la finalidad de generar un efecto sobre un proceso automatizado,
son muy utilizados en los aparatos mecatrónicos, como por ejemplo, en los robots. Los
motorreductores, servomotores, solenoides, etc. son los más utilizados en robótica.
BLUETOOTH
Bluetooth es una especificación industrial para Redes Inalámbricas de Área Personal (WPAN) que
posibilita la transmisión de voz y datos entre diferentes dispositivos mediante un enlace
por radiofrecuencia en la banda ISM de los 2,4 GHz. Los principales objetivos que se pretenden
conseguir con esta norma son:
Facilitar las comunicaciones entre equipos móviles y fijos.
Eliminar cables y conectores entre éstos.
Ofrecer la posibilidad de crear pequeñas redes inalámbricas y facilitar la sincronización de
datos entre equipos personales.
Los dispositivos Bluetooth se clasifican como "Clase 1", "Clase 2" o "Clase 3" en referencia a su
potencia de transmisión, siendo totalmente compatibles los dispositivos de una clase con los de
las otras.
Clase Potencia máxima permitida
(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
Hacer clic en siguiente
Figura 4.- Opciones de instalación
Esperar que termine la instalación de JAVA JDK 6
Figura 5.- Instalación en curso
34
Hacer clic en finalizar
Figura 3.- Instalación completa
Continuar con el paso 2
35
2.- Descargar, Instalar y Configurar ANDROID SDK
Link de descarga
http://developer.android.com/sdk/index.html
El instalador también se encuentra en la carpeta TOOLS del CD
Hacer clic en el botón marcado en rojo para comenzar la descarga
Figura 6.- Descarga de ANDROID SDK
36
Buscar el archivo descargado y ejecutar como administrador
Figura 7.- Ejecutar como administrador
Hacer clic en siguiente
Figura 8.- Ventana de bienvenida
37
Hacer clic en siguiente
Figura 8.- JAVA JDK encontrada
Hacer clic en siguiente
Figura 9.- Ruta de instalación
38
Hacer clic en siguiente
Figura 10.- Comienzo de la instalación
Hacer clic en siguiente
Figura 11.- Instalación completada
39
Hacer clic en finalizar y esperar que se ejecute el SDK MANAGER
Figura 12.- Ejecución del Asistente
40
Seleccionar los componentes Android SDK Platform-tools, SDK Platform y Google USB Driver
marcados en rojo y hacer clic en instalar.
Figura 13.- Selección de componentes
Marcar aceptar todos y Hacer clic en instalar
Figura 14.- Aceptar Términos
41
Ir a la ruta de instalación de ANDROID SDK y encontrar la carpeta Platform-tools
Figura 15.- Carpeta Platform-tools
Copiar la carpeta Platform-tools y pegar en la carpeta Platforms->Android-8
Figura 16.- Copiar y Pegar Platform-tools
42
Renombrar la carpeta pegada quedando como tools
Figura 17.- Carpeta Platform-tools renombrada
NOTA: para la instalación simple copiar en archivos de programa la carpeta ANDROID contenida
en la carpeta TOOLS del CD
Continuar con el paso 3
43
3.- Descargar, Instalar y Configurar Basic4Android
Link de descarga
http://www.basic4ppc.com/android/downloads.html
Hacer clic en el enlace marcado en rojo para comenzar la descarga
Figura 18.- Descarga de Basic4Android
44
Buscar el archivo descargado y ejecutar como administrador
Figura 19.- Ejecutar como administrador
Hacer clic en siguiente
Figura 20.- Ventana de bienvenida
45
Marcar aceptar los términos y hacer clic en siguiente
Figura 21.- Términos del software
Hacer clic en siguiente
Figura 22.- Ruta de instalación
46
Marcar crear acceso directo y Hacer clic en siguiente
Figura 23.- Creación de acceso directo
Hacer clic en instalar
Figura 24.- Comienzo de la instalación
47
Marcar ejecutar Basic4Android y hacer clic en finalizar.
Figura 25.- Instalación finalizada
Nota: Es necesario activar la versión completa para ello copiar en la raíz de la carpeta donde se
instaló Basic4Android el archivo b4a-license que está en la carpeta TOOLS-> Basic4android 1.5 del
CD, después repetir el proceso de instalación y ejecutar Basic4android e introducir el correo
contenido en el archivo clave que está en la carpeta TOOLS-> Basic4android 1.5 del CD, copiar en
la raíz de la carpeta donde se instaló Basic4Android las carpetas Libraries y Bibliotecas adicionales
que están en la carpeta TOOLS-> Basic4android 1.5 del CD. Al copiar seleccionar reemplazar
archivos si ya existen.
48
Ejecutar Basic4android y hacer clic en el menú Tools->Configure Paths.
Figura 26.- Configuración de directorios
Hacer clic en el primer botón Browse y buscar JAVAC.EXE en el directorio donde se instaló,
Después hacer clic en el segundo botón Browse y buscar en la carpeta Android-8 el archivo
ANDROID.JAR y por ultimo hacer clic en el tercer botón Browse y buscar la carpeta Bibliotecas
adicionales
Figura 27.- Ubicación de JAVAC.EXE Y ANDROID.JAR
49
Hacer clic en Tools->Run AVD manager y esperar que se ejecute el SDK MANAGER
Figura 28.- Ejecución de SDK MANAGER
En la barra de menú de SDK MANAGER hacer clic en Tool->Manage AVDs.
Figura 29.- Administrar AVDs
50
Hacer clic en nuevo
Figura 30.- Crear un AVD
Rellenar los siguientes campos y después dar clic en siguiente:
Name: MY_ANDROID_DEVICE
Target: Android 2.2 - API Level 8
Built-in: WQVGA400
Figura 31. - AVD creado
51
Hacer clic en OK
Figura 32.- Resultado del AVD creado.
Hacer clic en Start y después en Launch
Figura 33.- Ejecutar el AVD creado.
52
Esperar a que cargue el AVD
Figura 34.- AVD Iniciando
AVD listo para usar
Figura 35.- AVD Corriendo
53
Basic4android es un entorno de desarrollo sencillo y potente orientado a dispositivos Android, es
similar al lenguaje de Visual Basic con soporte adicional para los objetos. Incluye un potente diseñador de
interfaces de usuario con soporte integrado para múltiples pantallas y orientaciones. Es posible desarrollar
y depurar con el emulador de Android o con un dispositivo real mediante USB conectado o a través de la red
local.Basic4android tiene un amplio conjunto de librerías que facilitan el desarrollo de aplicaciones avanzadas.
Esto incluye: SQL, GPS, Bluetooth, cámara, IOIO, USB, servicios, JSON, animaciones, Wi-Fi, TTS,
reconocimiento de voz, gráficos, OpenGL, y más.
El Entorno de Desarrollo Integrado (IDE)
Al ejecutar el IDE obtendrá un formulario similar a la siguiente imagen:
54
1.- Menú y Toolbar
1.1.- Toolbar
55
1.2.- Menú Archivo
New 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
Hardware: Dispositivo Android
1. Ejecutar Basic4Android
2. Guardar el proyecto con el nombre LOAD LAYOUT desde el menú File->Save
3. Dar clic en el menú Designer
4. Conectarse al Emulador haciendo clic en el menú del Desginer Tools->Connect
El estado de la conexión se muestra debajo del menú
Es necesario que el emulador esté en funcionamiento para que pueda conectarse con el
Designer cuando la conexión se haya establecido el emulador quedara como se muestra
en la siguiente imagen
69
5. Diseñar el Layout: Ponerle el título Ejercicio 4 a la actividad, a través del menú
propiedades del Designer, la parte superior del menú indica el objeto que se está editando
y debajo aparecen las propiedades. Se puede explorar otras opciones de la actividad como
el fondo con la propiedad Drawable y por ejemplo poner de fondo un gradiente.
Agregar un Button al diseño haciendo clic en el menú del Desginer Add View->Button el
Button aparecerá en el emulador
Cuando los cuadros rojos aparecen alrededor de un View significa que esta seleccionado y
se puede arrastrar y cambiar su tamaño. Continuar con el diseño agregando los demás
Views restantes y acomodarlos para que todos sean visibles en la pantalla.
6. Guardar el Layout con el nombre mi_layout
7. Agregar al código la instrucción para cargar el Layout. La manera de cargar el diseño es por
medio del comando Actitvity.LoadLayout y solo se necesita como parámetro el nombre
del Layout. El momento para cargar el Layout es cuando la aplicación inicia esto es en el
evento Activity_Create. El comando deberá quedar como se muestra a continuación:
70
Activity.Loadlayout("nombre_del_layout")
El evento Activity_Create quedara de la siguiente manera (los textos en color verde son
comentarios):
Al escribir las instrucciones como Activity justo después de poner el punto el
autocompletado permite ver las funciones, parámetros, propiedades, etc.
8. Configurar la aplicación repitiendo el paso 4 del primer ejemplo con los siguientes
parámetros:
Include Debug Information: Desmarcar (en caso de estarlo)
Attach To Debugger: Desmarcar (en caso de estarlo)
Can Install To External Storage: Marcar
La única diferencia con el ejemplo anterior es que la aplicación se podrá instalar en la
memoria SD
9. Repetir los pasos 5 y 6 del ejemplo anterior e ingresar lo siguiente:
Package Name: ejercicio4.android
Label: Ejercicio 4
El resultado será el siguiente
71
La aplicación no hace mucho ya que el objetivo fue diseñar y cargar un Layout pero se puede
interactuar con los Views.
Otra forma de diseñar y ejecutar aplicaciones es desde el dispositivo real para ello es necesario
activar la depuración en el dispositivo y tener instalados los drivers. El primer paso es instalar el
software proporcionado en el CD de su dispositivo Android o bien descargar el software desde la
página del fabricante, con esto se instalaran los drivers, Después en el menú del dispositivo marcar
la opción de depuración a través de Ajustes->Aplicaciones->Desarrollo->Depuración USB. Luego
conectar el dispositivo y esperar a que esté listo para usar. Al momento de tratar de instalarse la
aplicación o de conectar con el Designer se hará con el emulador o en el dispositivo dependiendo
de cuál esté conectado en caso de estar presentes los dos aparecerá una ventana para seleccionar
con cual trabajar.
Reto: Diseñar un Layout en orientación Landscape con el dispositivo real
72
ACTIVITY MENU
Descripción de la aplicación: Muestra un mensaje según la opción seleccionada
Interfaz de usuario: Menú ítem (solo disponible desde código)
Hardware: Dispositivo Android
A partir de este punto se omitirán los pasos básicos tales como ejecutar el IDE, guardar el
proyecto, etc. Se usara siempre la opción de instalar la aplicación en el almacenamiento externo,
también se omitirán los comentarios de código en las imágenes para tener mayor espacio ya que
se proporciona todo el código fuente con comentarios. Todo lo anterior con el fin de enfocarse en
los nuevos conceptos.
Este ejemplo utiliza un tipo de control que solo se puede crear desde código conocido como menú
ítem y un tipo de mensaje utilizado en el ejercicio 2 a modo de reto, llamado Toastmessage, el
objetivo es entender el flujo del programa.
Nombre del Proyecto: ACTIVITY MENU
Package Name: ejercicio3.android
Application Label: Ejercicio 3
Los Ítems de menú aparecen cuando el usuario presiona la tecla menú del dispositivo. Para crear
un ítem se utiliza el comando Activity.AddMenuItem que necesita dos parámetros uno es el texto
del ítem y el otro es el evento o la subrutina asociada a el boton, recordar que los botones tiene
un evento principal que es el clic. La sintaxis del comando es la siguiente:
Activity.AddMenuItem("titulo","evento")
Es un comando de inicialización o construcción por lo tanto debe declararse en el evento
Activity_Create
73
Se ha construido dos ítems uno con el título opción 1 y el otro con el titulo opción 2. El parámetro
más importante es el evento puede ser cualquier texto pero se debe usar una metodología para
no equivocarse al momento de tocar el ítem opción 1 el flujo del programa buscara la subrutina
evento_opcion_1, pasara lo mismo con el Ítem opción 2. Por lo tanto además de definir un evento
habrá que construir la subrutina que pueden agregarse al final del código como se muestra a
continuación:
Cada subrutina comienza por Sub seguido del nombre del evento que siempre debe ser el mismo
que se declara como cuando construye un ítem seguido de un guion y el evento fundamental. Por
ejemplo se definió evento_opcion_1 y el evento fundamental es el clic en el caso del Ítem opción
1, Por lo tanto queda como evento_opcion_1_clic. Cada subrutina termina con End Sub y es en
este bloque donde se pondrán todas las acciones a realizar al tocar el Ítem. En este caso para cada
Ítem aparecerá un Mensaje tipo Toast al tocarlo
Al correr la aplicación y presionar el botón menú del dispositivo aparecerán los ítems y al tocar un
ítem aparecerá el mensaje Toast
74
Un mensaje Toast es aquel que se desvanece después de un tiempo
Reto: Aumentar los ítems y los mensajes a 4
BUTTON
Descripción de la aplicación: Muestra un mensaje al tocar el botón
Interfaz de usuario: 1 Button
Hardware: Dispositivo Android
En este ejemplo se hace uso del primer View para interactuar con la aplicación. Al tocar el botón
se mostrara un cuadro de mensaje (MSGBOX). Diseñar el Layout agregando un Button y guardarlo
con el nombre layout_ejercicio_5. El propósito de este ejemplo es vincular los Views con el código
Nombre del Proyecto: BUTTON
Package Name: ejercicio5.android
Application Label: Ejercicio 5
El primer paso para vincular el Boton con el código es declararlo, pero al ser un View esto se puede
hacer desde el designer por medio del menú Tools->Generate Members aparecerá una ventana
en la que se muestran los Views utilizados en el diseño y también la actividad
Al expandir los elementos aparecerán sus eventos
75
Se deben marcar los Views y eventos que se desean vincular al diseño en este caso se marcara el
Button1 y su evento clic y después dar clic al botón Generate members.
Automáticamente el objeto se declara en Sub Globals
Y también la subrutina correspondiente al evento del objeto, el comando Msgbox es agregado por
el usuario
Al correr la aplicación y tocar el Button1 uno aparecerá el Msgbox
76
Reto: Usar el Button1 con otro evento
LABEL
Descripción de la aplicación: Cambia el Texto de un Label al tocar un Button
Interfaz de usuario: 1 Button, 1 Label
Hardware: Dispositivo Android
A partir de este punto se omitirá también el proceso de diseño del Layout, generar los miembros y
cargar el Layout, en la parte superior de cada ejemplo se especifica los Views necesarios para la
interfaz de usuario, se proporciona además los Layout de cada ejercicio están en la carpeta
APLICACIONES ANDROID->FILES del CD, también se especificara las propiedades y eventos
necesario para cada View.
En este ejemplo se hace de un View visto anteriormente y un view de texto llamado Label. Al tocar
el boton el texto del Label cambiara.
Nombre del Proyecto: LABEL
Package Name: ejercicio6.android
Application Label: Ejercicio 6
El Layout deberá quedar como se muestra a continuación:
77
El código necesario para cambiar el texto del Label es a través de la propiedad Text y su sintaxis
es la siguiente:
Label1.Text="Cualquier_Texto"
El evento Click del Button1 deberá quedar de la siguiente manera
El resultado de la aplicación al tocar el Button1 será el siguiente
Reto: Agregar un botón para restablecer el texto del Label
78
SEEKBAR
Descripción de la aplicación: Muestra la posición de un Seekbar en un Label
Interfaz de usuario: 1 Seekbar, 1 Label
Hardware: Dispositivo Android
Nombre del Proyecto: SEEKBAR
Package Name: ejercicio7.android
Application Label: Ejercicio 7
El Layout deberá quedar como se muestra a continuación:
El Seekbar es un tipo de View numérico, dependiendo la posición en que se encuentre será su
valor, este valor se puede leer con la propiedad Value. El evento será ValueChanged que es
cuando cambia su posición. Los valores que toma son enteros y por medio de la propiedad Max se
puede configurar el máximo valor que puede tomar. El código necesario para leer la posición es el
siguiente:
Variable=SeekBar1.Value
Donde Variable es una variable declarada necesaria para guardar el valor, pero el lenguaje Basic
permite asignar directamente un valor entero a un Label. El código del evento del Seekbar deberá
quedar de la siguiente forma:
79
El resultado de la aplicación al deslizar el Seekbar será el siguiente
Reto: Avisar al usuario cuando se ha llegado al mínimo y al máximo valor
PROGRESSBAR
Descripción de la aplicación: Muestra la posición de un Seekbar en un Label y en un ProgressBar
Interfaz de usuario: 1 Seekbar, 1 Label, 1 ProgressBar
Hardware: Dispositivo Android
Nombre del Proyecto: ProgressBar
Package Name: ejercicio8.android
Application Label: Ejercicio 8
El Layout deberá quedar como se muestra a continuación:
80
El ProgressBar tiene el funcionamiento contrario al SeekBar se puede configurar la posición o
progreso a través de la propiedad Progress, siendo 100 el valor máximo que puede tomar, y
además no tiene eventos. El código necesario para escribir la posición es el siguiente:
ProgressBar1.Progress=algún valor entero
Donde algún valor entero puede ser una constante o una variable por ejemplo al leer la posición
de un Seekbar se obtiene un entero por lo cual se puede asignar directamente. El código del
evento del Seekbar deberá quedar de la siguiente forma:
El resultado de la aplicación al deslizar el Seekbar será el siguiente
Reto: Ajustar lo necesario para aumentar el rango a 1024
RADIOBUTTON
Descripción de la aplicación: Cambia el color del texto de un Label según la opción seleccionada
Interfaz de usuario: 3 RadioButton, 1 Label
Hardware: Dispositivo Android
81
Nombre del Proyecto: RADIOBUTTON
Package Name: ejercicio9.android
Application Label: Ejercicio 9
El Layout deberá quedar como se muestra a continuación:
El RadioButton es un control de selección y su estado puede saberse a través de la propiedad
Checked, siendo True o False los dos valores que puede tomar, el evento utilizado es el
CheckedChange que es cuando cambia de estado, cuando están agrupados solo se puede
seleccionar un RadioButton. El código necesario para leer su estado es el siguiente:
Variable=RadioButton1.Checked
Donde Variable es de tipo booleano, sin embargo la manera general de usar estos controles es a
través de bloques IF THEN.
Un color se puede establecer de una manera fácil por medio de la función Colors, el
autocompletado mostrara las diferentes opciones disponibles. Para este ejemplo se utilizan los
colores rojo, verde y azul
Cada RadioButton establece un color para el texto del Label por lo tanto se pondrá una instrucción
en cada evento correspondiente, el código deberá quedar como se muestra a continuación.
82
El resultado de la aplicación al seleccionar cada RadioButton será el siguiente:
Reto: agregar otro grupo de RadioButton para controlar el color del texto de otro Label
83
CHECKBOX
Descripción de la aplicación: Controla el estilo de un Label según las opciones marcadas
Interfaz de usuario: 3 CheckBox, 1 Label
Hardware: Dispositivo Android
Nombre del Proyecto: CHECKBOX
Package Name: ejercicio10.android
Application Label: Ejercicio 10
El Layout deberá quedar como se muestra a continuación:
El CheckBox es un control de selección igual al RadioButton, con la diferencia de que se puede
seleccionar más de uno. El código necesario para leer su estado es el siguiente:
Variable=CheckBox1.Checked
Donde Variable es de tipo booleano, sin embargo al igual que un RadioButton la manera general
de usar estos controles es a través de bloques IF THEN.
Este ejemplo es parecido al anterior con la diferencia que se controla el estilo de texto: negrita,
minúscula y resaltado, el código deberá quedar como se muestra a continuación.
84
El resultado de la aplicación al combinar las opciones será el siguiente:
Reto: Sustituir los CheckBox por ToggleButton
85
En el bloque anterior se desarrollaron aplicaciones básicas utilizando los principales Views para
familiarizarse con el entorno Basic4Android, a continuación se realizaran aplicaciones que incluyan
el uso de librerías para explorar las funciones características de Android como los sensores, las
notificaciones, el reconocimiento de voz, etc.
Al igual que en el capítulo anterior las aplicaciones listas para instalar y probar se encuentran en la
carpeta APK del CD, también el código fuente y el proyecto de las aplicaciones se encuentran en la
carpeta APLICACIONES ANDROID del CD
ANIMATION
Descripción de la aplicación: Anima un objeto con la librería ANIMATION
Interfaz de usuario: 2 Button, 6 RadioButton
Hardware: Dispositivo Android
Nombre del Proyecto: ANIMATION
Package Name: ejercicio11.android
Application Label: Ejercicio 11
El Layout deberá quedar como se muestra a continuación:
86
La librería Animation está orientada a aplicar animaciones a los Views, para utilizar cualquier
librería es necesario incluirla en el proyecto marcando la correspondiente de las que aparecen
disponibles en la pestaña Libs del lado inferior derecho del IDE, la librería Core siempre aparecerá
marcada ya que contiene los comandos básicos para cualquier aplicación.
La librería ANIMATION ofrece 6 tipos diferentes de animaciones, para construir una aplicación
primero se debe declarar el objeto como tipo Animation en este caso lo que se pretende es
explorar las 6 opciones por lo tanto se debe declarar esa cantidad de objetos, también se necesita
87
una variable que se declara como x que más adelante se explica, el código correspondiente a la
declaración debe quedar de la siguiente manera:
Cualquier variable que se declara en Basic se declara de la siguiente forma:
Dim nombre_de_la_variable As tipo_de_variable
En la parte Sub Globals del código aparecen también los objetos declarados ya que esto lo hace
automáticamente el designer al generar miembros. El siguiente paso es construir cada una de las
animaciones, ya que esto es una creación o inicialización el código deberá ir en la parte
Activity_Create como se muestra a continuación:
88
Para una animación se debe definir 4 cosas: el tipo de animación, la duración de la animación, las
veces que se repetirá y el modo de repetición. Las tres últimas son iguales para todos los tipos y se
establecen por medio de las propiedades Duration, RepeatCount y RepeatMode respectivamente.
El desarrollador no debe olvidar para acceder a las propiedades primero se escribe el nombre del
objeto seguido de punto y el autocompletado muestra todas sus propiedades, constantes y
funciones. La duración se expresa en milisegundos, la cantidad de repeticiones en un entero y el
modo de repetición por medio de una constante del propio objeto que puede ser
REPEAT_REVERSE O REPEAT_RESTART, lo que significa que la animación hará reversa o reiniciara
89
para repetir. Un punto muy importarte para tener una idea de la sintaxis de los comandos es
identificar qué tipo de propiedad es, en un objeto pueden aparecer los siguientes símbolos:
El primero (mano) indica que la propiedad necesita un valor proporcionado a través del operador
de asignación =, Como es el caso de Duration. El segundo símbolo (cuadro purpura) indica que la
propiedad es más compleja que necesita ciertos parámetros como es el caso de LoadLayout() , casi
siempre de esa forma con los paréntesis. El último icono (cuadro azul) significa que es una
constante y se debe usar como en el caso de Repeat_Reverse. El IDE muestra también ejemplos
de sintaxis como en el caso de los tipos de animación. Para ilustrar cada tipo de animación se
utilizan 6 RadioButton y un boton para ejecutar la acción de iniciar la animación. Por lo tanto se
debe checar el estado de cada RadioButton y de alguna forma hacerle saber al boton cual esta
seleccionado. Esto se hace por medio de la variable X como se muestra a continuación:
90
El Button2 será el encargado de iniciar las animaciones por medio de la propiedad Start, cabe
aclarar que el Button1 solo sirve para que a través de él se muestre la animación de un View, el
código quedara de la siguiente manera:
El resultado de la aplicación (animaciones alpha, rotate y scale) será el siguiente
Reto: Controlar las coordenadas de la animación translate por medio del evento Touch de la
actividad
91
TTS
Descripción de la aplicación: Convierte de texto a voz
Interfaz de usuario: Sin interfaz de usuario
Hardware: Dispositivo Android
Nombre del Proyecto: TTS
Package Name: ejercicio12.android
Application Label: Ejercicio 12
La librería TTS (Text To Speech) es una función de Android que permite convertir texto en voz
implementado desde la versión 2.2 de Android (froyo). Para utilizar esta característica es necesario
tener instalado en el dispositivo los datos de voz, esto se puede verificar en el menú Ajustes-
>Entrada y Salida de Voz->Ajustes de síntesis de Voz->Escuchar un ejemplo, si no se logra
escuchar el ejemplo será necesario instalar los datos de voz a través de Ajustes->Entrada y Salida
de Voz->Ajustes de síntesis de Voz->Instalador Datos de Voz, Este proceso conduce a la tienda en
línea de Google para descargar los datos.
El primer paso es marcar la librería TTS, después declarar el objeto sintetizador_de_voz como tipo
TTS como se muestra a continuación:
El siguiente paso es inicializar el objeto a través de la propiedad Initialize y requiere solo de un
parámetro en este caso un evento que se nombrara como Event_sintetizador el código debe
quedar de la siguiente manera:
92
El evento fundamental del TTS es cuando ha terminado de inicializarse llamado Ready y por medio
de su variable local Success se puede saber si la operación fue exitosa o surgió algún problema,
para sintetizar un texto se utiliza la propiedad Speak y se ingresan dos parámetros uno es el texto
a sintetizar y el otro especifica si se puede interrumpir la síntesis o terminar (esto en caso de que
en el momento de estar “hablando” se presente otra instrucción de síntesis). El código queda de la
siguiente manera:
El resultado de la aplicación será un mensaje de voz al iniciar
Reto: Implementar las propiedades Pitch y SpeechRate
VOICE RECOGNITION
Descripción de la aplicación: Convierte de voz a texto
Interfaz de usuario: 1 Button
Hardware: Dispositivo Android
Nombre del Proyecto: VOICE RECOGNITION
Package Name: ejercicio13.android
Application Label: Ejercicio 13
La librería VOICE RECOGNITION (reconocimiento de voz) es una función de Android que permite
convertir texto en voz implementado desde la versión 2.2 de Android (froyo), No todos los
fabricantes implementan esta función por lo tanto habrá que averiguar si el dispositivo lo soporta,
una forma es verificar si está instalada la aplicación de búsqueda por voz. El principio de
funcionamiento es el siguiente: el usuario indica que introducirá un comando de voz, la aplicación
indica el momento para hacerlo, graba el mensaje, la envía a un servidor, y el servidor regresa las
coincidencias. Este proceso es muy rápido pero requiere conexión a internet.
93
En este caso la librería a incluir es la llamada Phone ya que Basic4android la considera una función
telefónica se necesita declarar un objeto tipo VoiceRecognition pero requiere que sea en el área
Sub Process_Globals, el nombre será VR, el código deberá quedar de la siguiente manera:
El siguiente paso es inicializar el objeto con el nombre de un evento, como se mencionó
anteriormente es posible saber si la función de reconocimiento de voz es soportada a través de la
propiedad IsSupported, la propiedad Prompt establece el texto para indicar que es momento de
hablar. El código correspondiente se muestra a continuación:
El reconocimiento de voz responde a un evento llamado Result que es cuando se ha completado el
proceso, a través de Success se puede saber si se realizó con éxito o hubo algún problema, y los
resultados de la conversión se obtienen de la variable Texts, el código es el siguiente:
94
Con lo cual se muestra a través de un mensaje Toast el primer resultado obtenido, se toma el
primer elemento de la lista con Get(). El último paso es iniciar el reconocimiento de voz con el
evento clic del Button1 esto se logra con la propiedad Listen del objeto VR como se muestra a
continuación:
Para correr la aplicación es necesario desde el dispositivo
Reto: Mostrar todos los resultados de la lista
TIMER
Descripción de la aplicación: Muestra un contador
Interfaz de usuario: 2 Button, 1 Label
Hardware: Dispositivo Android
Nombre del Proyecto: TIMER
Package Name: ejercicio14.android
Application Label: Ejercicio 14
El Timer es un objeto muy importante en el desarrollo de aplicaciones, Junto con las
interrupciones forman la base para el multiproceso. El Timer está implementado en la librería
Core por lo tanto no es necesario marcar ninguna extra.
El Layout deberá quedar como se muestra a continuación:
95
Se necesita declarar un objeto tipo Timer en el área Sub Globals con el nombre Temporizador,
también una variable tipo Byte con el nombre X, el código deberá quedar de la siguiente manera:
El siguiente paso es inicializar el objeto con el nombre de un evento y una cantidad entera que
expresa el tiempo en que se generara una interrupción en milisegundos. El código
correspondiente se muestra a continuación:
El Timer responde a un evento llamado Tick que significa una cuenta o que ha pasado el tiempo
especificado para interrumpir, en esta subrutina se incrementa la variable X para después mostrar
un contador en el Label1, el código es el siguiente:
96
Se utilizan 2 Button uno para iniciar y el otro para detener las interrupciones del Timer a través de
su propiedad Enabled, el código es el siguiente:
El resultado será un contador en pantalla.
Reto: Utilizar un SeekBar para configurar el tiempo de cada cuenta.
PROXIMITY SENSOR
Descripción de la aplicación: Detecta la proximidad de un objeto
Interfaz de usuario: 1 ProgressBar, 1 Label
Hardware: Dispositivo Android, algún objeto
Nombre del Proyecto: PROXIMITY SENSOR
Package Name: ejercicio15.android
Application Label: Ejercicio 15
El Sensor de proximidad parte del hardware del teléfono utilizado para funciones telefónicas, su
rango de alcance varía según el dispositivo, pero no mide distancia si no que indica si hay algo
cercano o no. Para utilizarlo es necesario incluir la librería Phone.
El Layout deberá quedar como se muestra a continuación:
97
Se necesita declarar un objeto tipo PhoneSensors en el área Sub Globals con el nombre
Proximidad, el código deberá quedar de la siguiente manera:
El siguiente paso es inicializar el objeto con el tipo de sensor, esto se hace a través de una
constante del propio objeto llamado TYPE_PROXIMITY. El código correspondiente se muestra a
continuación:
Para hacer que el sensor comience a funcionar automáticamente se utiliza el evento
Activity_Resume para que de esa forma vuelva a funcionar si la aplicación regresa del segundo
plano, esto se logra a través de StartListening y se especifica el nombre del evento, el evento
Acitivity_Pause se utiliza para liberar el sensor con StopListening y pueda ser utilizado por otra
aplicación:
98
El sensor de proximidad responde a un evento llamado SensorChanged que es cuando un objeto
se aproxima o aleja, en esta subrutina se muestra en un Label el valor que entrega el sensor a
través de la variable Values() y después se compara para mostrar una representación en un
ProgressBar, el código es el siguiente:
La aplicación necesita probarse en el dispositivo real ya que en el emulador no se cuenta con un
sensor de proximidad.
Reto: Hacer que el dispositivo vibre al acercarse un objeto.
MAGNETOMETER
Descripción de la aplicación: Mide la intensidad de campo magnético
Interfaz de usuario: 1 ProgressBar, 1 Label
Hardware: Dispositivo Android, algún objeto metálico o inductivo
Nombre del Proyecto: MAGNETOMETER
Package Name: ejercicio16.android
Application Label: Ejercicio 16
El Sensor magnético es parte del hardware del teléfono utilizado como brújula electrónica,
orientación, detector de metales, etc., la gran mayoría de los dispositivos Android implementan
este sensor, mide la intensidad de campo magnético en los tres ejes X,Y,Z, la librería para usar este
sensor es Phone como en el ejemplo anterior.
El Layout deberá quedar como se muestra a continuación:
99
Se necesita declarar un objeto tipo PhoneSensors en el área Sub Globals con el nombre
Magnetometer, y también 3 variables tipo Float para guardar las lecturas del sensor, el código
deberá quedar de la siguiente manera:
El siguiente paso es inicializar el objeto con el tipo de sensor, esto se hace a través de una
constante del propio objeto llamado TYPE_MAGNETIC_FIELD. El código correspondiente se
muestra a continuación:
100
Para hacer que el sensor comience a funcionar automáticamente se utiliza el evento
Activity_Resume para que de esa forma vuelva a funcionar si la aplicación regresa del segundo
plano, esto se logra a través de StartListening y se especifica el nombre del evento, el evento
Acitivity_Pause se utiliza para liberar el sensor con StopListening y pueda ser utilizado por otra
aplicación:
El sensor magnético responde a un evento llamado SensorChanged que es cuando cambia el valor
del campo magnético en cualquiera de los ejes, en esta subrutina los valores que entrega el sensor
se guardar en sus respectivas variables, a una cuarta variable se le asigna el total del valor del
campo magnético haciendo una operación matemática (raíz cuadrada), se muestra el resultado en
un Label y en un ProgressBar, el código es el siguiente:
La aplicación necesita probarse en el dispositivo real ya que en el emulador no se cuenta con un
sensor magnético.
Reto: Hacer una aplicación que detecte metal.
101
ADVANCED CAMERA
Descripción de la aplicación: Captura una foto
Interfaz de usuario: 1 Panel, 1 ImageView, 1 Button
Hardware: Dispositivo Android
Nombre del Proyecto: ADVANCED CAMERA
Package Name: ejercicio17.android
Application Label: Ejercicio 17
La cámara es un dispositivo muy importante en robótica con ella se pueden hacer aplicaciones por
ejemplo para robots exploradores a un bajo costo y fácil implementación, para usarla en
basic4android se utilizara el propósito básico que es capturar imágenes y guardarlas, la librería
para usar el hardware se llama ADVANCED CAMARA, esta librería de terceros tiene más funciones
que la librería original de Basic4android
El Layout deberá quedar como se muestra a continuación:
Se necesita declarar un objeto tipo AdvancedCamara en el área Sub Globals con el nombre
Cámara, el código deberá quedar de la siguiente manera:
102
El siguiente paso es inicializar el objeto especificando un panel y el nombre de un evento, el
parámetro más importante es el medio que se usa para mostrar el preview de la cámara y siempre
será un panel. El código correspondiente se muestra a continuación:
Para hacer que el sensor comience a funcionar automáticamente se utiliza el evento Ready de la
cámara y a través de Success se verifica si la inicialización fue exitosa, se establece la orientación
de la cámara en retrato por medio de la propiedad OriPortrait y por último se pone en
funcionamiento a través de StarPreview. El evento Acitivity_Pause se utiliza para liberar el sensor
con Release para que pueda ser utilizado por otra aplicación, pero antes se detiene el preview con
StopPreview, el código queda de la siguiente manera:
Para tomar una fotografía se construye una subrutina debe llamarse siempre PictureTaken ya que
actuara como un evento de la cámara que básicamente lo que hace es abrir un medio para escribir
en memoria un archivo, por lo pronto el lector no le debe prestar mucha importancia a entender
las instrucciones con respecto a la variable Out, después de la captura la imagen se muestra en un
ImageView, el código es el siguiente:
103
En Android existen 5 directorios para trabajar con archivos:
File.DirAssets: Se trata de archivos distribuidos con la aplicación en el empaquetado APK, para
incluir archivos con la aplicación se utiliza la pestaña Files y con el boton Add Files como se
muestra en la imagen
File.DirInternal / File.DirInternalCache: Estas dos carpetas se almacenan en la memoria principal y
son privadas para la aplicación, ninguna otra aplicación puede accesar a estos archivos.
File.DirRootExternal: el directorio raíz del almacenamiento externo (memoria SD)
File.DirDefaultExternal: La carpeta predeterminada para una aplicación en almacenamiento
externo. Otras aplicaciones pueden acceder a la carpeta mediante la ruta: [dispositivo externo] /
Android / data / [nombre del paquete] / files /
En el ejemplo se usa el directorio File.DirRootExternal para guardar la imagen. Para mostrar la
captura se utiliza el ImageView1 y por medio de la propiedad Bitmap se carga la imagen con ayuda
de la función LoadBitmap, esta función requiere dos parámetros uno es el directorio y el otro el
nombre completo del archivo.
104
Por ultimo con un Button se llama a la subrutina para tomar capturar la fotografía con TakePicture
como se muestra en el código:
Al correr la aplicación con el emulador el resultado es el siguiente:
Reto: Agregar la función de tomar foto con cuenta regresiva.
ABZXING
Descripción de la aplicación: Leer códigos de barra
Interfaz de usuario: 1 Button
Hardware: Dispositivo Android, código de barras o QR
Nombre del Proyecto: ADVANCED CAMERA
105
Package Name: ejercicio18.android
Application Label: Ejercicio 18
La función de tomar fotos con la cámara no es suficiente para implementarse en proyectos de
robótica, pero reconocer objetos requiere también de conocimientos más avanzados, la librería
ABZXING proporciona la función de escanear códigos de barras de una manera sencilla a través
del enlace con la aplicación BarcodeScanner, se necesita tener instalada esta aplicación que se
proporciona en la carpeta APK del CD e incluir la librería ABZXING en el proyecto
El Layout deberá quedar como se muestra a continuación:
Se necesita declarar un objeto tipo ABZXING en el área Sub Globals con el nombre Escáner, el
código deberá quedar de la siguiente manera:
El comienzo del escaneo es controlado por el Button1 con la propiedad ABGetBarCode y se
especifica el evento y el tipo de código a leer, en este caso códigos de barras de productos, el
código es el siguiente:
106
El ABZXING responde al evento BarCodeFound que es cuando ha terminado de escanear, y el
código decodificado se obtiene a través de la variable Barcode y se muestra con un cuadro de
dialogo (MSGBOX), el código es el siguiente:
Es necesario correr la aplicación con un dispositivo real.
Reto: Modificar la aplicación para escanear códigos QR.
ACELEROMETER
Descripción de la aplicación: Mide la aceleración en los ejes X, Y, Z
Interfaz de usuario: 3 Label
Hardware: Dispositivo Android
Nombre del Proyecto: ACELEROMETER
Package Name: ejercicio19.android
Application Label: Ejercicio 19
El acelerómetro es un sensor que está en todos los dispositivos Android y provee una mayor
experiencia multimedia en las aplicaciones, entrega el valor de la aceleración en los tres ejes X, Y,
Z, la librería para usar este sensor es Phone como en el ejemplo anterior.
El Layout deberá quedar como se muestra a continuación:
107
Se necesita declarar un objeto tipo PhoneAccelerometer en el área Sub Globals con el nombre
Acelerómetro, el código deberá quedar de la siguiente manera:
Para hacer que el sensor comience a funcionar automáticamente se utiliza el evento
Activity_Resume para que de esa forma vuelva a funcionar si la aplicación regresa del segundo
plano, esto se logra a través de StartListening y se especifica el nombre del evento, el evento
Acitivity_Pause se utiliza para liberar el sensor con StopListening y pueda ser utilizado por otra
aplicación:
108
El acelerómetro responde a un evento llamado AccelerometerChanged que es cuando cambia el
valor de la aceleración en cualquiera de los ejes, en esta subrutina los valores que entrega el
sensor se muestran en un Label para cada una de las variables, el operador & concatena el texto
fijo y el valor de la variable, el código queda de la siguiente forma:
La aplicación necesita probarse en el dispositivo real ya que en el emulador no se cuenta con un
acelerómetro.
Reto: Detectar inclinación los ejes X, Y (usar los valores 4 y -4 para comparar).
TABHOST
Descripción de la aplicación: Carga 3 Layout utilizando un View TABHOST
Interfaz de usuario: TabHost
Hardware: Dispositivo Android
Nombre del Proyecto: ACELEROMETER
Package Name: ejercicio20.android
Application Label: Ejercicio 20
El TabHost es un view útil para cuando la interfaz de usuario no alcanza en la pantalla, para esto se
requiere un Layout por cada pestaña del View, No se necesita ninguna librería esta ya que esta
implementado en Core
Primero se necesita diseñar un layout con el control TabHost, el diseño debe como se muestra a
continuación
109
Después es necesario crear 3 Layout adicionales ya que en el ejemplo se usara 3 pestañas, es
importante que los Views tengan diferente nombre en cada layout, después de crear los layout
deberán agregarse por medio de la pestaña Files de Basic4android, Los layout se muestran a
continuación:
Y los layout deberán aparecer agregados al proyecto como se muestra en la siguiente imagen:
110
Si al momento de abrir el código fuente el programa indica que no se encuentra algún archivo
como por ejemplo un layout, se deberá ubicar el archivo por este medio. Esto sucede cuando hay
un cambio de lugar de la carpeta donde se guardó el código, todos los layout utilizados en esta
guía se ubican en la carpeta APLICACIONES ANDROID->FILES del CD.
La construcción del TabHost se lleva a cabo en el evento Activity_Create, para ello se va añadiendo
cada pestaña por medio de AddTab y se define el titulo y el layout, el código queda de la siguiente
manera:
El resultado es el siguiente:
111
Reto: Integrar la aplicación 3 aplicaciones de las anteriores utilizando un TabHost
NOTIFICATION
Descripción de la aplicación: Muestra una notificación en la barra de estado al iniciar la aplicación
Interfaz de usuario: Sin interfaz de usuario
Hardware: Dispositivo Android
Nombre del Proyecto: NOTIFICATION
Package Name: ejercicio21.android
Application Label: Ejercicio21
Las notificaciones en la barra de estado son una característica muy peculiar de Android, por este
medio un proceso notifica al usuario al recibir un nuevo correo, mensaje, programa en ejecución,
etc. También establecen la interacción del usuario con los servicios, esta función esta
implementada en el Core así que no es necesario alguna librería extra.
Lo primero es declarar un Objeto tipo Notificatión con el nombre Notificación
Después se construye la notificación en el evento Activity_Create, se inicializa solo con Initialize,
después se indica el icono que aparecerá en la barra de notificaciones en este caso al poner
“icon”se usa el icono de la aplicación (se puede poner otro icono con LoadBitmap), después con
SetInfo se proporciona la información de la notificación especificando el título, el contenido y a
qué actividad llamar cuando se toque la notificación en este caso al poner solo los símbolos “”
indica que ira a la actividad Main , por últimos se despliega la notificación con Notify() (el número
1 se refiere a se afecta a la primera notificación) , el código queda de la siguiente manera:
112
Al correr la aplicación aparece una notificación en la barra de estado y se debe deslizar para ver el
contenido:
Reto: Desplegar una notificación cuando el reconocimiento de voz tenga resultados.
MEDIAPLAYER
Descripción de la aplicación: Reproduce un archivo de audio WAV al iniciar la aplicación
Interfaz de usuario: Sin interfaz de usuario
Hardware: Dispositivo Android
Nombre del Proyecto: MEDIAPLAYER
Package Name: ejercicio22.android
Application Label: Ejercicio22
El MediaPlayer es una función que reproduce archivos de audio, esto le da un toque decorativo a
la aplicación por ejemplo en un robot se puede usar los sonidos de R2D2, el objeto esta
implementado en el Core así que no es necesario alguna librería extra.
Lo primero es declarar un Objeto tipo MediaPlayer con el nombre MP en el área de Sub
Process_Globals. Después en el evento Activity_Create se inicializa poniendo la propiedad
113
Initialize, luego se indica el archivo a reproducir por medio de Load especificando el directorio y el
nombre del archivo (previamente agregado con la pestaña Files), por último se reproduce con
Play, el código queda de la siguiente manera:
Reto: Controlar el volumen multimedia con un SeekBar.
RTC
Descripción de la aplicación: Obtiene la fecha y hora
Interfaz de usuario: 6 Label, 1 Button
Hardware: Dispositivo Android
Nombre del Proyecto: RTC
Package Name: ejercicio27.android
Application Label: Ejercicio27
Este ejemplo utiliza la función de fecha y hora para implementar un reloj tipo calendario. Esta
implementado en el Core por lo tanto no se necesita incluir alguna librería extra
El layout deberá quedar de la siguiente manera:
114
No se necesita declarar algún objeto específico para hora y fecha, pero si se necesita una variable
para guardar el tiempo actual, que debe ser una variable Long ya que la dimensión de datos en
grande, al inicio un MSGBOX muestra la fecha y hora actual en un formato por medio de la función
DateTime.Now(), después a través de las demás funciones se descompone por horas, minutos,
etc. , para actualizar el tiempo se utiliza el Button1, el código queda de la siguiente manera:
Declaración de variables y objetos:
Inicialización:
115
Actualización con el Button1:
El resultado de la aplicación será el siguiente:
116
Reto: Actualización automática del tiempo.
GPS
Descripción de la aplicación: Muestra la información de los satélites GPS
Interfaz de usuario: 4 Label
Hardware: Dispositivo Android
Nombre del Proyecto: GPS
Package Name: ejercicio26.android
Application Label: Ejercicio26
El sensor GPS indica la posición actual y el estado de los satélites a los que está conectado el
dispositivo Android. La funcionalidad para poder acceder al GPS es por medio de la librería GPS.
Esta función requiere una conexión de dato activa y habilitar el uso de satélites GPS en el menú del
dispositivo Ajustes->Ubicación Y Seguridad->Usar Satélites GPS.
El layout deberá quedar como se muestra en la imagen
El objeto GPS debe de ser declarado en Sub Process_Globals, para no declararlo cada vez que necesite utilizarlizarse. El código queda de la siguiente manera:
117
El segundo paso es iniciar el objeto GPS, utilizando el parámetro Initialize, el código queda de la siguiente manera:
En Activity_Resume se verifica si el GPS está activado por medio de GPSEnabled, si no lo esta se
envía un mensaje al usuario para activarlo, en caso de estar activado se pone en funcionamiento
por medio de Start (), los dos ceros se refieren a el tiempo mínimo y distancia mínima a la que sea
desea leer los cambios, generándose un evento cuando uno de los dos ha cambiado de valor, en
este caso trabajara a la máxima frecuencia y resolución, en el evento Activity_Pause se detiene el
GPS con Stop el código queda de la siguiente manera:
El GPS responde a tres eventos LocationChanged, UserEnabled y GpsStatus. En este ejemplo se
utiliza el primero y el ultimo.
118
En el evento LocationChanged se obtiene la información de la posición (latitud, longitud y
velocidad) por medio de las propiedades ConverToMinutes() y Speed, Después se muestra el
resultado en los Label1, Label2 y Label1 respectivamente.
En el evento GpsStatus se obtiene por medio de un ciclo For que va de 0 hasta la cantidad de
satélites conectados, en la Label4 se muestra esta información.
Es necesario probar la aplicación en el dispositivo real.
Reto: Agregar cada satélite encontrado en un View Spinner y mostrar su información en un
MSGBOX al tocar el Ítem.
119
En este capítulo se construirá el hardware necesario para establecer interfaces con dispositivos
Android, se considera que el lector tiene experiencia en la construcción de circuitos impresos, se
proporciona la lista de materiales, el diagrama esquemático y el PCB, el proyecto se encuentra en
la carpeta PCB del CD.
PIC USB
La tarjeta PIC USB está diseñada para la implementación rápida de prototipos ya que su firmware
puede ser actualizado desde una conexión USB y la distribución de los componentes electrónicos
facilita la conexión de hardware extra, está basada en el microcontrolador PIC18F2550 a
continuación se describen las partes más importantes:
ENTRADA USB conecta la tarjeta a través del USB a la computadora para actualizar el firmware
ALIMENTACION EXTERNA entrada de pilas o fuente de alimentación. Rango de 6 a 30 V.
120
SELECTOR DE ALIMENTACION a través de un jumper se selecciona si la tarjeta se alimenta desde
el USB o a través de la alimentación externa.
PUERTOS I/O 0-9 entradas y salidas correspondientes al PORTC (8 y 9) con función especial de
UART y al PORTB (0-7) con funciones especiales de bus I2C e Interrupciones.
PUERTOS I/O 10-12 entradas y salidas correspondientes al PORTC con función especial de salidas
PWM.
PUERTOS I/O 13-17 entradas y salidas correspondientes al PORTA con función especial de
entradas analógicas.
BOOT botón para entrar en modo boot.
LED POWER indicador de alimentación.
LED RUN indicador de modo boot.
PUERTO ICSP conector para actualización de firmware por medio de un programador de
microcontroladores
La lista de materiales necesarios para su construcción es la siguiente:
1 Microcontrolador PIC PIC18F2550
1 Cristal de cuarzo de 20 MHZ
1 Regulador de 5v LM7805
2 LED de 3 mm
1 Push Button
2 Capacitores electrolíticos de 47 uf
1 Capacitor cerámico de 0.1 uf
1 Capacitor cerámico de 470 nf
2 Resistor de 330 ohm
1 Resistor de 10 k
1 Base para CI de 28 Pines
1 Conector USB tipo B hembra
1 Terminal de 2 pines
1 Tira de pines macho
1 Tira de pines Hembra
1 Jumper
1 Placa fenólica de una cara de 5x10
El diagrama esquemático se muestra a continuación
121
122
Los componentes deben quedar montados según la siguiente imagen:
El PCB es el siguiente:
La tarjeta terminada deberá quedar de la siguiente forma:
123
El siguiente paso es programar el microcontrolador a través de un programador externo a través
del puerto ICSP el archivo a descargar al microcontrolador se llama Bootloader.hex se encuentra
en la carpeta HEX del CD, a continuación se detalla el orden de los pines en la tarjeta.
Para verificar el funcionamiento de la tarjeta primero se debe energizar, el LED POWER deberá
encender, después conectar el cable USB y presionar el botón BOOT, la computadora deberá
reconocer el dispositivo y en breve deberá parpadear el LED RUN.
MODULO BLUETOOTH
Esta modulo facilita la conexión con la tarjeta PIC USB a través de una conexión UART, está basado
en el dispositivo HC-06 que actúa como un puerto serie para establecer la conexión con un
dispositivo Android:
BLUETOOTH HC-06 dispositivo bluetooth modelo HC-06
LED STATUS indica el estado de la conexión.
RESISTORES adaptan los niveles de voltaje para compatibilidad 5V.
124
REGULADOR 3.3V proporciona alimentación al módulo bluetooth
La lista de materiales necesarios para su construcción es la siguiente:
1 Bluetooth HC-06
1 Regulador 3.3 V
1 LED
1 Resistor 330 ohm
1 Resistor 10 k
1 Resistor 15 K
4 Pines
1 Placa fenólica una cara 5x5
El diagrama esquemático se muestra a continuación
Los componentes en rojo van en la parte sin cobre de la placa y los componentes en gris donde
están las pistas ya que son de montaje superficia , deben quedar montados según la siguiente
imagen:
125
En caso de utilizar un regulador diferente los pines GND deben quedar unidos y el orden de las
conexiones se muestra en la imagen:
El PCB es el siguiente:
La tarjeta terminada deberá quedar de la siguiente forma:
Para verificar el funcionamiento del módulo bluetooth se debe alimentar por medio de los pines
VDD Y GND con 5v, esto se puede lograr conectándolo a la tarjeta PIC USB, a continuación se
detalla la interfaz UART del módulo y su conexión con la tarjeta:
126
Y la conexión con la tarjeta PIC USB debe quedar de la siguiente forma:
La siguiente figura muestra el modulo conectado a la tarjeta:
El último paso es encontrar el modulo Bluetooth con el dispositivo Android aparecerá con el
nombre Linvor
127
IOIO BOARD
La tarjeta IOIO DE Sparkfun es un hardware dedicado a la interfaz con dispositivos Android
utilizando la depuración, actúa como un HOST USB, para mejorar la alimentación de la tarjeta se
ha diseñado un adaptador
ENTRADA USB proporciona alimentación a la tarjeta IOIO
ALIMENTACION EXTERNA entrada de pilas o fuente de alimentación. Rango de 5 a 30 V.
SELECTOR DE ALIMENTACION a través de un jumper se selecciona si la tarjeta se alimenta desde
el USB o a través de la alimentación externa.
PUERTOS I/O 1-18 entradas y salidas dela tarjeta IOIO.
PUERTOS I/O 33-48 entradas y salidas dela tarjeta IOIO.
POWER switch on-off de alimentación.
ENTRADA PARA CARGA proporciona energía a las baterías.
128
La lista de materiales necesarios para su construcción es la siguiente:
1 tarjeta IOIO
3 pines macho
4 Tiras de pines hembra
1 Jack o bornera para PCB
1 Terminal de 2 pines
1 Conector USB tipo B
1 Microswitch
1 Jumper
1 Placa fenólica de una cara de 5x10
El diagrama esquemático se muestra a continuación
Los componentes deben quedar montados según la siguiente imagen:
129
El PCB es el siguiente:
Para la base del IOIO se ha usado pines hembra dobles para mayor estabilidad, pero basta con
pines sencillos, el área con driles (huecos) se puede usar para una interfaz UART e I2C los grupos
de 4 son para los pines y los demás para colocar 2 resistencias de 10k, la tarjeta terminada deberá
quedar de la siguiente forma:
Para comprobar el funcionamiento se debe energizar la tarjeta (se encenderá el LED rojo ) y
conectar el dispositivo Android al IOIO, deberá estar activada la depuración, la tarjeta será
reconocida por el dispositivo y el LED amarillo del IOIO dará un destello.
130
En este capítulo se desarrollaran aplicaciones para conectar hardware externo a un dispositivo
Android para controlar cargas o para leer el estado de algún sensor, es recomendable contar con
un protoboard y algunos componentes electrónicos como LED’s, Potenciómetros, Servomotores,
para hacer más interactivo el aprendizaje, se utilizara el software PICC para los programas de la
tarjeta PIC USB.
INTERFAZ BLUETOOTH
Como primer ejemplo se desarrollara la aplicación más sencilla que consiste en construir un
esqueleto de aplicación con las funciones básicas como conectarse a un dispositivo y notificar,
esto servirá de base para desarrollar futuras aplicaciones para una interfaz bluetooth.
Las aplicaciones listas para instalar y probar se encuentran en la carpeta APK del CD.
El código fuente y el proyecto de las aplicaciones se encuentran en la carpeta APLICACIONES
ANDROID del CD
El código fuente para la tarjeta PIC USB se encuentra en la carpeta APLICACIONES PIC del CD,
también en este apartado se explica el algoritmo para establecer la interfaz.
BLUETOOTH
Descripción de la aplicación: Realiza funciones básicas para una interfaz bluetooth
Interfaz de usuario: Sin Layout
Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta PIC USB
Nombre del Proyecto: BLUETOOTH
Package Name: ejercicio23.android
Application Label: Ejercicio23
131
Para utilizar el Bluetooth en Basic4android se debe incluir la librería Serial al proyecto ya que este
es el perfil más sencillo a utilizar.
Para una aplicación bluetooth se debe conocer ciertos puntos como el estado de la conexión, la
lista de dispositivos vinculados, el dispositivo con el que se quiere trabajar, etc. El primer paso es
declarar un objeto tipo Serial en el área de Process_Globals para poder utilizar el bluetooth.
El siguiente paso es inicializar el bluetooth creando un evento a través de la propiedad Initialize, el
código se muestra a continuación:
El primer punto a considerar es monitorear el estado del bluetooth, para avisarle al usuario que lo
active en caso de no estarlo ya que no es posible usarlo si está activado, y si está activado tiene
que ponerse a escuchar las conexiones entrantes para que otros dispositivos puedan hacer
peticiones de conexión. El estado se obtiene a través de la propiedad IsEnabled y para escuchar
conexiones es a través de la propiedad Listen, el momento efectivo para hacerlo es en el evento
Activity_Resume, el código queda de la siguiente manera:
132
Es posible correr la aplicación y verificar el funcionamiento, de otra forma el siguiente punto a
considerar es obtener la lista de dispositivos apareados o vinculados, este resulta ser el paso más
complejo en todo el proceso. El momento más adecuado para obtener la lista es cuando el usuario
intenta conectarse a un dispositivo bluetooth como el módulo de la tarjeta PIC USB, como no se
diseñó ningún Layout el medio para iniciar el proceso de conexión será un ítem de menú, esto
resulta cómodo ya que solo ocupara la pantalla cuando sea necesario, por lo tanto se comenzara
por construir 2 ítem de menú para controlar la conexión y desconexión. El código debe quedar de
la siguiente forma:
Y sus respectivos eventos quedan de la siguiente manera:
Para obtener la lista de dispositivos apareados se necesita una lista y un mapa que básicamente
son arreglos de objetos que almacenan cadenas de caracteres de información, como por ejemplo
en el caso del bluetooth se almacena el nombre de un dispositivo y su dirección MAC, ya que
pueden ser varios dispositivos la búsqueda se realiza con un ciclo For, las variables se deben
definir como se muestra a continuación:
133
Primero se debe guardar en un mapa la lista de dispositivos apareados mediante
GetpairedDevices
Después se inicializa la lista, luego se copia a la lista todo el contenido del mapa, el tamaño del
mapa se obtiene con Size, y con GetKeyAt () se obtiene cada elemento del mapa.
Este proceso se debe implementar tal y como se muestra en el código de ejemplo, no es necesario
tratar de entender que es lo que hace cada instrucción si no el algoritmo. El lector tal vez se
preguntara por que se usa un mapa y no se almacena directamente en una lista, la razón es
porque la propiedad GetPairedDevices retorna un mapa, el código debe quedar implementado
como se muestra a continuación:
Ya que se ha obtenido la lista de dispositivos apareados el siguiente paso es desplegar la lista para
que el usuario seleccione un dispositivo para conectarse. Esto se logra con el comando InputList
que necesita como parámetros la lista que debe mostrar (esta es otra razón por lo cual se usa una
lista), el título, y el dispositivo seleccionado por default (-1 indica que no se selecciona ninguno).
InputList(Lista, "Seleccionar Dispositivo", -1)
134
El código queda de la siguiente manera:
Hasta el momento al correr la aplicación el resultado será el siguiente:
Se puede apreciar que un InputList es un conjunto de RadioButtons y la propiedad es que cuando
están agrupados solo uno puede seleccionarse, esto es eficaz para seleccionar el dispositivo para
conectarse (ahí el motivo de usar lista).
El siguiente paso es realizar la conexión con el dispositivo seleccionado, en el código mostrado
anteriormente el InputList se le asignó a la variable Dispositivo_Selecionado, esta variable debe
ser declarada como tipo int, antes de dar la orden conectar se debe saber si se seleccionó algún
dispositivo de la lista, esto se logra por medio de DialogResponse.Cancel . Por último se da la
orden conectar por medio de Connect, que resulta ser una instrucción más compleja pero lo que
135
Hace es obtener la dirección MAC del dispositivo seleccionado para conectarse. El código
modificado se muestra a continuación:
El penúltimo paso es monitorear el estado de la conexión con el evento Connected del bluetooth
que por medio de la variable Success indica si la operación fue exitosa o hubo algún problema, Ya
que esta variable es local no se podrá usar en otra parte del código para preguntar el estado de la
conexión, para ello se requiere usar una variable auxiliar de tipo Boolean, el código
correspondiente se muestra en la siguiente imagen:
En el evento Connected se pregunta si la conexión fue exitosa, se establece el valor de la variable
Conectado y por medio de un mensaje Toast se notifica al usuario.
136
El último paso es finalizar la conexión por medio de la propiedad Disconnect del bluetooth, el ítem
de menú (desconectar) y el cierre de la aplicación controlan la desconexión, solo es necesario
desconectarse cuando se encuentra conectado a un dispositivo y para ello se utiliza la variable
Conectado, el código debe quedar de la siguiente manera:
Con esto se ha concluido el desarrollo de la aplicación base para bluetooth, el siguiente paso es
preparar la interfaz. El resultado al conectarse con algún dispositivo será el siguiente:
137
LA INTERFAZ
El modulo bluetooth viene con las siguientes configuraciones de fábrica:
BaudRate: 9600
Paridad: N (sin paridad)
Bits de datos: 8
Bits de parada: 1
ID: linvor
Password: 1234
Al conectar el modulo bluetooth a la tarjeta PIC USB y energizarlo el LED comenzara a parpadear y
al realizar la búsqueda con el dispositivo Android aparecerá como se muestra en la siguiente
imagen
138
Al seleccionar el dispositivo de nombre linvor aparecerá un dialogo pidiendo la contraseña,
introducir 1234:
El dispositivo aparecerá con la leyenda “vinculado.Deconectado”, como se muestra en la imagen
de abajo:
Con esto queda todo listo para continuar con el siguiente ejemplo.
BLUETOOTH TX
Descripción de la aplicación: Controla un LED por medio de bluetooth
Interfaz de usuario: 1 Label, 2 Button
139
Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta PIC USB, LED
Nombre del Proyecto: BLUETOOTH TX
Package Name: ejercicio24.android
Application Label: Ejercicio24
Utilizando el ejemplo anterior se agregara la función de enviar datos a través de bluetooth hacia el
modulo conectado a la tarjeta PICUSB, el objetivo es prender y apagar un LED conectado al pin 0.
El algoritmo es sencillo, consiste en enviar un carácter “1” para encender y “2” para apagar.
El layout debe quedar como se muestra en la siguiente imagen:
El medio necesario para el envió de caracteres se conoce como TextWriter, este objeto se debe
declarar en el área Sub Globals, el código queda como se muestra a continuación:
140
El siguiente paso es inicializar el TextWriter y el momento preciso es cuando se ha establecido la
conexión, se debe inicializar como un medio de salida de datos, para ello se usa la propiedad
OutputStream del bluetooth, el código debe quedar de la siguiente manera:
Para enviar caracteres a traves del TextWriter se utiliza la propiedad Write() especificando los
caracteres a enviar, la funcion Flush limpia el TexWriter, se utiliza la variable conectado ya que si
se envian datos sin una conexión activa Android arrojara un error.Por ultimo el estado del LED se
indica en un Label. El codigo queda de la siguiente manera:
141
La tarjeta PIC USB debe tener conectado un LED como se muestra en la imagen
El código fuente se encuentra en la carpeta APLICACIONES PIC del CD, para editarlo abrir el
archivo BLUETOOTH_RX.c el código está desarrollado en PIC C de CCS.
El archivo listo para su descarga a la tarjeta se encuentra en la carpeta HEX del CD, conectar la
tarjeta PIC USB mientras se presiona el botón BOOT hasta que el LED RUN comience a parpadear,
después abrir el programa PICUSB LOADER que se encuentra en la carpeta TOOLS del CD, el
resultado será una ventana como esta:
Device attached indica que la tarjeta esta lista, para descargar el archivo dar clic en el botón
Importar y buscar el archivo BLUETOOTH_RX.hex, después dar clic al botón Programar, el
programa indicara el progreso como se muestra en la siguiente imagen:
142
El último paso es dar clic en el botón Correr, el LED dejara de parpadear y el programa comenzara
a funcionar.
BLUETOOTH RX
Descripción de la aplicación: Muestra el carácter recibido por medio de bluetooth
Interfaz de usuario: 1 Label
Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta PIC USB
Nombre del Proyecto: BLUETOOTH RX
Package Name: ejercicio25.android
Application Label: Ejercicio 25
Utilizando el ejercicio 23 se agregara la función de recibir datos a través de bluetooth enviados por
el modulo conectado a la tarjeta PICUSB según el estado del botón BOOT, el objetivo es ver en un
Label el carácter recibido.
El layout debe quedar como se muestra en la siguiente imagen:
143
El medio necesario para la recepción de caracteres se conoce como TextReader, este objeto se
debe declarar en el área Sub Globals. No existe un evento que responda cuando se ha recibido un
carácter, por lo tanto es necesario preguntar periódicamente con un Timer, el código queda como
se muestra a continuación:
El siguiente paso es inicializar el TextReader y el momento preciso es cuando se ha establecido la
conexión tal como se hizo con el envío de caracteres, se debe inicializar como un medio de
entrada de datos, para ello se usa la propiedad InputStream del bluetooth, en esta parte el Timer
se habilita pero debe inicializarse para interrumpir cada 10 ms (no se muestra en la imagen puesto
que se explicó anteriormente). El código debe quedar de la siguiente manera:
Para recibir caracteres a traves del TextReader se utiliza el evento del Timer y para leer los datos
es necesario que se cumplan 2 cosas: que exista una conexión activa y el TextReader este listo,
esto se verifica por medio de la variable Conectado y la propiedad Ready. Para mostrar los datos
en el Label se utiliza la propiedad ReadLine, es importante que al momento de enviar el carácter
144
Con el microcontrolador se use el terminador de linea “\n” . El codigo queda de la siguiente
manera:
El último paso es deshabilitar el Timer como se hizo al finalizar la conexión bluetooth, cuando se
cierra la aplicación y cuando se desconecta, el código queda de la siguiente manera:
El código fuente se encuentra en la carpeta APLICACIONES PIC del CD, para editarlo abrir el
archivo BLUETOOTH_TX.c el código está desarrollado en PIC C de CCS.
Cargar el archivo BLUETOOTH_RX.hex a la tarjeta.
Reto: combinar los 2 ejercicios anteriores en una sola aplicación, El código fuente para interfaz se
encuentra en la carpeta APLICACIONES PIC del CD, para editarlo abrir el archivo
BLUETOOTH_RXTX.c el código está desarrollado en PIC C de CCS, cargar el archivo
BLUETOOTH_RXTX.hex a la tarjeta.
145
INTERFAZ IOIO
Como primer ejemplo se desarrollara la aplicación más sencilla que consiste en construir un
esqueleto de aplicación con las funciones básicas para utilizar la tarjeta IOIO y controlar el LED
OnBoard.
Las aplicaciones listas para instalar y probar se encuentran en la carpeta APK del CD.
El código fuente y el proyecto de las aplicaciones se encuentran en la carpeta APLICACIONES
ANDROID del CD
IOIO
Descripción de la aplicación: Controla el LED OnBoard de la tarjeta IOIO
Interfaz de usuario: 1 ToggleButton
Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta IOIO, adaptador para IOIO
Nombre del Proyecto: IOIO
Package Name: ejercicio28.android
Application Label: Ejercicio28
Para utilizar la tarjeta IOIO en Basic4android se deben incluir las librerías IOIO y IOIOlib al
proyecto.
El layout debe quedar como se muestra en la siguiente imagen:
146
Para una aplicación con IOIO el primer paso es declarar un objeto tipo IOIO y un objeto tipo
DigitalOutput en el área de Sub Globals
El siguiente paso es inicializar el IOIO simplemente con la propiedad Initialize, después esperar la
conexión de la tarjeta por medio de WaitForConnect, mostrar la versión de hardware, por ultimo
abrir un PIN como salida
en este caso el 0 ya que el LED OnBoard se conecta a ese pin, en caso de necesitar otra salida solo
se debe cambiar el número, el código se muestra a continuación:
Al salir de la aplicación se debe cerrar los pines utilizados y desconectar de la tarjeta IOIO, esto se
logra por medio de las propiedades Close Y Disconnect() respectivamente, el evento
Activity_Pause queda de la siguiente manera:
147
Para controlar el encendido del LED se utiliza el evento CheckedChange del ToggleButton, a través
de la propiedad Write se escribe el dato de salida, el LED se activa en bajo por lo que se usa el
comando Not() para invertir el estado del ToggleButton en la escritura como se muestra en la
siguiente imagen:
Al ejecutar la aplicación y conectar la tarjeta el resultado será el siguiente:
IOIO ANALOG
Descripción de la aplicación: Muestra la lectura de una entrada analógica
Interfaz de usuario: 1 ProgressBar, 1 Label
Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta IOIO, adaptador para IOIO,
Potenciómetro
Nombre del Proyecto: IOIO ANALOG
Package Name: ejercicio29.android
148
Application Label: Ejercicio29
.
El layout debe quedar como se muestra en la siguiente imagen:
La diferencia con el ejercicio anterior es que se debe declarar un objeto tipo AnalogInput y al igual
que en el ejemplo BLUETOOTH RX se utilizara un Timer para la lectura de datos, el código queda
de la siguiente manera:
El Timer se debe inicializar a 30 milisegundos y habilitar justo después de que se conecta la tarjeta,
en este caso se utiliza el pin 40 para abrir una entrada analógica en caso de necesitar otra entrada
solo se debe cambiar el número (33-46), el código se muestra a continuación:
149
Al salir de la aplicación se debe deshabilitar el Timer, cerrar los pines utilizados y desconectar de la
tarjeta IOIO, el evento Activity_Pause queda de la siguiente manera:
Para leer la entrada analógica se utiliza el evento Tick del Timer, a través de la propiedad Voltaje
se obtiene la tensión de entrada en el pin analógico (no debe ser mayor de 3.3 v para no dañar el
IOIO), y este valor es asignado a un Label, por último se hace un ajuste para representar el voltaje
de entrada en un ProgressBar como se muestra en la siguiente imagen:
La tarjeta IOIO debe tener conectado un potenciómetro como se muestra en la imagen
150
Al ejecutar la aplicación y conectar la tarjeta el resultado será el siguiente:
IOIO PWM OUTPUT
Descripción de la aplicación: Controla la intensidad de un LED o posición de un servo
Interfaz de usuario: 1 SeekBar, 1 Label
Hardware: Dispositivo Android, Modulo Bluetooth, Tarjeta IOIO, adaptador para IOIO, LED, Servo
Nombre del Proyecto: IOIO PWM OUTPUT
Package Name: ejercicio30.android
Application Label: Ejercicio30
151
.
El layout debe quedar como se muestra en la siguiente imagen:
La diferencia con el ejercicio anterior es que se debe declarar un objeto tipo PwmOutput, el
código queda de la siguiente manera:
En este ejercicio se utiliza el pin 12 para abrir una salida PWM a 1 khz en caso de necesitar otra
entrada solo se debe cambiar el número (3-7,9-14), el código se muestra a continuación:
152
Al salir de la aplicación se debe cerrar los pines utilizados y desconectar de la tarjeta IOIO, el
evento Activity_Pause queda de la siguiente manera:
Para controlar la salida PWM se utiliza el evento ValueChanged del SeekBar, a través de la
propiedad PulseWidth se controla el ancho de pulso de la salida PWM (de 0 a 1024), y este valor
es asignado a un Label, pero este proceso se debe realizar solo si la salida PWM esta lista, esto se
verifica por medio de la propiedad IsInitialized como se muestra en la siguiente imagen:
La tarjeta IOIO debe tener conectado un LED como se muestra en la imagen
También se puede conectar un servo como se muestra en la imagen
153
Al ejecutar la aplicación y conectar la tarjeta el resultado será el siguiente:
154
DESCRIPCION
DROID es un Robot-Smartphone basado en una interfaz Bluetooth con la tarjeta PIC USB, Es un medio didáctico para el desarrollo de aplicaciones móviles, utiliza el teléfono como accesorio o como cerebro, aprovechando la potencia de los procesadores de un teléfono inteligente y sensores, es accesible, expandible, ya que aumenta la funcionalidad del robot, es económico y de fácil construcción.
ESTRUCTURA MECÁNICA
El chasis está construido con PVC espumado mejor conocido como Sintra es un material liviano, resistente, termoformable, autoextinguible, no absorbe la humedad, se puede cortar, aserrar, pintar, perforar, etc., Sin embargo el lector puede utilizar otro material para construir su estructura ya que dependerá del tipo de motores que utilice, los motores utilizados en el robot fueron sacados de unos carritos de juguete, que tienen una relación de 50:1. Loa motores recomendados son los motorreductores de plástico ya que las ruedas están diseñadas para estos motores. La Sintra está disponible en modo de pliegos de diferentes tamaños y colores, un cúter y kola loca será necesario para cortar las piezas y unirlas para formar la estructura. En la imagen de abajo se muestra algunos pliegos de Sintra
Los motorreductores de plástico se pueden encontrar en tiendas especializadas de robótica, al igual que las ruedas. Una buena elección de motorreductor es con la relación 1:48, que
155
Proporcionará 200 rpm y un rango de alimentación de 3 a 12 v. En la imagen de abajo se muestra un motorreductor y las ruedas de la empresa Robodacta.
Con paciencia y dedicación se puede construir una estructura utilizando los materiales mencionados anteriormente y lograr tener montados los motores, incluso una base hecha de trovicel para colocar el Smartphone como se muestra en la siguiente imagen del robot Androidmie.
Droid es mucho más simple debido al reciclaje de los motores y ruedas, por lo que ha quedado de la siguiente forma:
156
ELECTRONICA
La electrónica consta de tres partes una es la tarjeta PIC USB, la segunda el modulo bluetooth y la tercera el DROID SHIELD, este último es el encargado de proporcionar el driver para controlar los motores, la conexión de la energía y los sensores. El proyecto se encuentra en la carpeta PCB del CD.
El DROID SHIELD está diseñado para albergar la tarjeta PIC USB y utiliza un chip SN75441110NE
como driver de los motores, a continuación se describen las partes más importantes:
ENTRADA PARA PILAS terminal de 2 tornillos para alimentar el circuito
CONECTOR MOTOR L terminal de 2 tornillos para conectar el motor izquierdo.
CONECTOR MOTOR R terminal de 2 tornillos para conectar el motor derecho
DRIVER chip SN754410NE puente H
BASE PARA PIC USB tiras de pines hembra para conectar la tarjeta PIC USB
CONECTOR SENSOR L 3 pines macho para conectar el sensor de proximidad izquierdo
CONECTOR SENSOR R 3 pines macho para conectar el sensor de proximidad derecho
SENSORES EXTRA área para conectar hasta 3 sensores analógicos
157
La lista de materiales necesarios para su construcción es la siguiente:
1 Driver Puente H SN754410NE
1 Base para CI de 16 Pines
3 Terminal mini de 2 pines
2 Tira de 3 pines macho
1 Tira de pines Hembra
1 Placa fenólica de una cara de 5x10
El diagrama esquemático se muestra a continuación
158
Los componentes deben quedar montados según la siguiente imagen:
El PCB es el siguiente:
Adicionalmente se puede dar un acabado a la placa con los Labels
La tarjeta terminada deberá quedar de la siguiente forma:
159
Droid posee 2 sensores de proximidad GP2Y0A21YK0F de la marca Sharp que miden la distancia a
la que se encuentra un objeto en un rango de 10 a 80 cm, estos sensores entregan una tensión
analógica dependiendo de la distancia, funcionan con un voltaje de alimentación de 4.5 a 5.5 v y
un consumo típico de 30 mA, en la siguiente figura se muestra el sensor y las conexiones
necesarias:
Para conectarlos es necesario un cable especial llamado JST de 3 vías, el sensor y cable se pueden
encontrar en tiendas como Robodacta y Pololu.
Los sensores deben quedar conectados como se muestra en la siguiente figura:
160
Los sensores cuentan con unos orificios en los costados para atornillarse, en el robot han quedado
de la siguiente manera:
.
Para la conexión de los motores es necesario soldar entre los terminales de cada motor un
capacitor de 0.1 uf para reducir el ruido eléctrico que generan, y la conexión en el DROID SHIELD
debe quedar como se muestra en la siguiente imagen:
161
El robot utiliza 6 pilas recargables AAA de Ni-Cd conectadas en serie para proporcionar un voltaje
7.2 V , y una corriente de 1 A, se puede usar cualquier otra pila con la restricción en corriente de
hasta 2 A y un voltaje de 12 V como máximo, en la siguiente imagen se muestra como se deben
conectar:
El robot con toda la electrónica montada queda como se muestra en la siguiente imagen:
162
Para verificar el funcionamiento de los motores cargar el archivo TEST_MOTORES.HEX contenido
en la carpeta HEX del CD, el robot realizara la siguiente secuencia: Adelante-Atrás-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
El Layout deberá quedar como se muestra a continuación:
168
Esta aplicación es muy similar a la desarrollada en el ejercicio 24 en la que un botón controla el
encendido de un LED enviando un carácter. La diferencia es que ahora un SeekBar controla la
intensidad de un LED por lo que se requiere enviar más de un carácter, la técnica consiste en
implementar un protocolo de comunicaciones propio, que contenga un carácter de inicio, los
datos y un carácter de fin. En este ejemplo se utiliza como delimitadores los paréntesis entonces el
protocolo queda de la siguiente forma:
(datos)
Entonces al enviar los caracteres en el evento del SeekBar el código quedara dela siguiente
manera:
Se puede apreciar que el envío no es difícil, pero el procesamiento de la cadena de caracteres en
el Microcontrolador es un poco más elaborado. Para empezar el Microcontrolador debe detectar
el momento en que llega el carácter “(“, después guardar los datos y la posición en la que se
encuentran, detectar el carácter “)“ para reiniciar el ciclo, y por ultimo convertir esa cadena de
texto en un valor. Es recomendable el uso de interrupciones por UART para evitar la pérdida de
datos.
Teniendo en cuenta que el SeekBar Varia de 0 a 100 el mínimo numero de caracteres que puede
enviar son 3 y el máximo son 5, para (0) y (100) respectivamente. Entonces es necesario declarar
una variable char en forma de arreglo para guardar los datos, siendo 5 la dimensión mínima, el
código del Microcontrolador usa para ello la siguiente línea:
char dato[10];
Para detectar cada carácter recibido se utiliza la función Kbhit() , al recibir cada carácter se debe ir
guardando en la variable dato[] especificando la posición en los corchetes, debido a que no se
169
Sabe en qué momento se recibirán 3,4 o 5 caracteres la posición de los datos y del carácter de fin
“)” será variable, por lo tanto se usa la variable entera Position para usarla como apuntador como
se muestra a continuación:
if(kbhit())
{
dato[position]=getc();
}
El siguiente paso es detectar el carácter de inicio, servirá para saber que inicia la trama e indicar
mediante una variable llamada Inicio que ya se puede incrementar la variable Position y acomodar
el dato en la siguiente posición del arreglo:
if(dato[position]==40)
{
inicio=1;
}
Luego se incrementa la posición mediante la variable Inicio:
if(inicio==1)
{
position=position+1;
}
El siguiente paso es detectar el fin de la cadena para reiniciar el ciclo, es decir hacer el apuntador
Position = 0, la bandera Inicio=0 y guardar la posición en la que terminan los datos, que siempre es
una posición antes que el carácter “)”. El código queda de la siguiente manera:
if(dato[position]==41)
{
fin=position-1;
inicio=0;
position=0;
}
Ahora solo resta extraer los datos y convertirlos a un valor numérico, si se han recibido 3
caracteres (para un valor del SeekBar de un digito por ejemplo 5) las variables quedan como
Position=2, Fin=1, por lo tanto los caracteres se han acomodado de la siguiente forma: dato[0]=”(“,
dato[1]=”5“ y dato*2]=”)“. Si se han recibido 4 caracteres (para un valor del SeekBar de dos dígitos
170
Por ejemplo 20) las variables quedan como Position=3, Fin=2, por lo tanto los caracteres se han
acomodado de la siguiente forma: dato [0]=”(“, dato[1]=”2“, dato*2]=”0“ y dato*3]=”)“. Si se han
recibido 5 caracteres (para un valor del SeekBar de tres dígitos por ejemplo 100) las variables
quedan como Position=4, Fin=3, por lo tanto los caracteres se han acomodado de la siguiente
forma: dato [0]=”(“, dato[1]=”1“, dato*2]=”0“, dato*3]=”0“ y dato*4]=”)“. Conociendo estos
valores es posible convertir a un valor numérico, como los caracteres se envían en código ASCII el
carácter “0” corresponde al valor decimal 48, por lo tanto se le resta esa cantidad, de esta forma
se obtienen los dígitos. El último paso es formar la cantidad multiplicando cada digito por su valor
correspondiente (unidad, decena y centena) y sumarlos, el código queda de la siguiente manera:
if(fin==1)
pwm=dato[1]-48;
if(fin==2)
pwm=(dato[1]-48)*10+(dato[2]-48);
if(fin==3)
pwm=(dato[1]-48)*100+(dato[2]-48)*10+(dato[3]-48);
El valor del SeekBar ha quedado guardado en la variable pwm. El código correspondiente a la
tarjeta PIC USB se encuentra en la carpeta APLICACIONES PIC del CD con el nombre
SEEKBAR_Y_PWM.c
PROGRESSBAR Y ADC
Descripción de la aplicación: Muestra la lectura de un canal analógico
Interfaz de usuario: 1 Label, 1 ProgressBar
Hardware: Dispositivo Android, Tarjeta PIC USB, Modulo Bluetooth, Potenciómetro
Nombre del Proyecto: PROGRESSBAR_Y_ADC
Package Name: PROGRESSBAR_Y_ADC.ANDROID
Application Label: PROGRESSBAR Y ADC
Técnica: Envió de más de un carácter por bluetooth con el microcontrolador
El Layout deberá quedar como se muestra a continuación:
171
Esta aplicación es muy similar a la desarrollada en el ejercicio 25 en la que el Boton BOOT de la
tarjeta PIC envía un carácter de acuerdo a su estado. La diferencia es que ahora se lee un canal
analógico de la tarjeta por lo que se requiere enviar más de un carácter, la técnica en el caso del
microcontrolador consiste en formatear la cadena usando instrucciones printf, en basic4android
la recepción de los caracteres y su conversión es facilitada por medio del lenguaje por lo que los
datos de entrada se pueden asignar directamente al Label y al ProgressBar
Entonces al recibir los caracteres en el evento del Timer el código quedara dela siguiente manera:
Para el envío de datos con el microcontrolador se usa la instrucción printf y su sintaxis es la
siguiente:
Printf(“ “);
172
Para enviar un valor fijo basta con poner el texto entre “ “ , por ejemplo para enviar un 100 el
comando queda de la siguiente manera:
Printf(“100“);
Sin embargo la lectura del ADC es una cantidad variable, para enviar variables se puede usar los
siguientes formateadores de cadena:
c 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
El Layout deberá quedar como se muestra a continuación:
Esta aplicación es muy similar a la desarrollada en el ejercicio SEEKBAR_Y_PWM en la que un
SeekBar controla la intensidad de un LED enviando más de un carácter. La diferencia es que ahora
son 3 SeekBar controlando la intensidad de 3 LED (correspondientes a Rojo, Verde y Azul del LED)
por lo que se requiere enviar más de un carácter y una forma de diferenciar un valor de otro, la
técnica consiste agregar un identificador único para cada variable al protocolo de comunicaciones
propio,. En este ejemplo se utiliza como identificadores las letras R,G y B por lo que el protocolo
queda de la siguiente manera
(datosIdenfiticador)
174
Entonces al enviar los caracteres en el evento de cada SeekBar se muestra en los Label la posición
y se utiliza la instrucción Colors.RGB() para colorear el Label, el código quedara dela siguiente
manera:
Al igual que el ejemplo mencionado anteriormente el envío no es difícil, y en cuanto al programa
del microcontrolador solo habrá que agregar el código para detectar cada identificador
Para detectar cada carácter identificador se utiliza la parte de código donde se detecta el fin de la
cadena para reiniciar el ciclo y guardar en una variable llamada Identificador el carácter recibido
que indica R,G o B, y los datos ahora terminaran dos posiciones antes antes que el carácter “)”. El
código queda de la siguiente manera:
175
if(dato[position]==41)
{
identificador=dato[position-1];
fin=position-1;
inicio=0;
position=0;
}
Ahora solo resta extraer los datos como en el ejemplo antes mencionado y asignarlo a la variable
correspondiente dependiendo del identificador, el código queda de la siguiente manera:
if(identificador=='R')
{
if(fin==2)
pwm1=dato[1]-48;
if(fin==3)
pwm1=(dato[1]-48)*10+(dato[2]-48);
if(fin==4)
pwm1=(dato[1]-48)*100+(dato[2]-48)*10+(dato[3]-48);
}
if(identificador=='G')
{
if(fin==2)
pwm2=dato[1]-48;
if(fin==3)
pwm2=(dato[1]-48)*10+(dato[2]-48);
if(fin==4)
pwm2=(dato[1]-48)*100+(dato[2]-48)*10+(dato[3]-48);
}
if(identificador=='B’)
{
if(fin==2)
pwm3=dato[1]-48;
if(fin==3)
pwm3=(dato[1]-48)*10+(dato[2]-48);
if(fin==4)
pwm3=(dato[1]-48)*100+(dato[2]-48)*10+(dato[3]-48);
}
176
El valor del SeekBar1 ha quedado guardado en la variable pwm1, el valor del SeekBar2 ha quedado
guardado en la variable pwm2 y el valor del SeekBar3 ha quedado guardado en la variable pwm3.
El código correspondiente a la tarjeta PIC USB se encuentra en la carpeta APLICACIONES PIC del
CD con el nombre LED_RGB.c
MULTIPLES LECTURAS
Descripción de la aplicación: Muestra la lectura de 3 canales analógicos
Interfaz de usuario: 4 Label, 3 ProgressBar
Hardware: Dispositivo Android, Tarjeta PIC USB, Modulo Bluetooth, 3 Potenciómetro
Nombre del Proyecto: MULTIPLES_LECTURAS
Package Name: MULTIPLES_LECTURAS.ANDROID
Application Label: MULTIPLES LECTURAS
Técnica: Envió de más de un carácter y más de una variable por bluetooth con el microcontrolador
y su procesamiento en Basic4Android.
El Layout deberá quedar como se muestra a continuación:
Esta aplicación es muy similar a la desarrollada en el ejercicio PROGRESSBAR_Y_ADC en la que se
lee un canal analógico de la tarjeta PIC USB y se envían varios caracteres . La diferencia es que
177
Ahora se leen 3 canales analógicos de la tarjeta por lo que se requiere enviar más de un carácter y
diferenciar cada variable al enviarlas, en basic4android la recepción de los caracteres y su
conversión es facilitada por medio del lenguaje por lo que los datos de entrada se pueden asignar
directamente al Label y al ProgressBar, pero habrá que implementar un algoritmo para identificar
cada canal analógico, esto se logra con el uso de identificadores como en el caso del ejemplo LED
RGB, entonces al recibir los caracteres en el evento del Timer se tendrá que procesar la cadena y el
lenguaje simplifica este proceso.
Lo primero que se debe saber es el tamaño de la cadena, el identificador (siempre el penúltimo
carácter), y después unir los caracteres, se utiliza un Label para recibir la cadena y 3 Label para
cada canal analógico, el código correspondiente al algoritmo cuando la cantidad enviada es de un
digito quedara dela siguiente manera:
El código correspondiente al algoritmo cuando la cantidad enviada es de dos dígitos quedara dela
siguiente manera:
178
El código correspondiente al algoritmo cuando la cantidad enviada es de tres dígitos quedara dela
siguiente manera:
Para el envío de datos con el microcontrolador se usa la instrucción printf como en el ejemplo
PROGRESSBAR_Y_ADC, pero agregando el identificador en este caso se ha usado A,B y C:
printf("%uA\n",ADC1/2);
printf("%uB\n",ADC2/2);
printf("%uC\n",ADC3/2);
delay_ms(70);
La lectura del canal analógico 0 ha quedado guardado en el Label2, la lectura del canal analógico 1
ha quedado guardado en el Label3 y la lectura del canal analógico 2 ha quedado guardado en el
Label4. El código correspondiente a la tarjeta PIC USB se encuentra en la carpeta APLICACIONES
PIC del CD con el nombre MULTIPLES_LECTURAS.c
SERVICIO
Descripción de la aplicación: Lectura continua de datos por Bluetooth
Interfaz de usuario: 1 Label
Hardware: Dispositivo Android, Tarjeta PIC USB, Modulo Bluetooth
Nombre del Proyecto: SERVICIO
Package Name: BLUETOOTHCONTINUOS.ANDROID
Application Label: BLUETOOTH CONTINUOS
179
Técnica: Monitorear continuamente la recepción de datos Bluetooth (incluso con el dispositivo
Bloqueado o en reposo).
El Layout deberá quedar como se muestra a continuación:
El primer paso es crear un servicio, el módulo de servicio se agrega desde el menú Project como se
muestra en la siguiente imagen
Aparecerá una ventana pidiendo el nombre del servicio, en este ejemplo se ha usado Notificador
El servicio será el encargado de algunas funciones de la conexión Bluetooth y la recepción de
datos, Por lo tanto lo primero es declarar todos los elementos necesarios para tales funciones, ya
que un servicio no tiene interfaz de usuario no es posible usar un Label para guardar los caracteres
recibidos por lo que se tiene que declarar una variable tipo String, el código queda de la siguiente
manera:
180
El siguiente paso es inicializar el Timer y Bluetooth como en ejemplos anteriores, pero ahora en el
evento Service_Create que es cuando se crea el servicio, el código quedara dela siguiente manera:
Después en el evento Service_Start el servicio se debe ejecutar por medio de la función
StartForeground() especificando una notificación (no olvidar que la notificación es el modo de
interactuar con el usuario), por lo tanto habrá que declarar el objeto tipo Notification y una
variable Int para contar las notificaciones, el código quedara dela siguiente manera:
En el evento Tick del Timer se procesan los datos recibidos como en ejemplos anteriores y si se
recibe un “2” se despliega una nueva notificación, el código queda como se muestra a
continuación:
181
Por ultimo en el evento Service_Destroy que es cuando se destruye el servicio se deberá finalizar
la conexión Bluetooth, el código queda de la siguiente manera:
El siguiente paso es construir la Actividad , en esta se deberá cargar el layout, y el único objeto
declarado deberá ser un Label que es el del Layout, la Actividad será quien controle el inicio y
cierre del servicio y la obtención de los dispositivos apareados , por lo tanto habrá que declarar 3
menú ítem, el código queda de la siguiente manera:
El evento clic del ítem Menu_conectar se encarga de obtener la lista de dispositivos y demás pasos
como se vio en ejemplos anteriores, con la única diferencia de que habrá que llamar a cada
variable y objeto poniendo antes el nombre del servicio seguido de punto como se muestra a
continuación:
182
También en el evento Connected del Bluetooth habrá que hacer los cambios en el código
mencionados anteriormente y deberá quedar como se muestra en la imagen:
183
El último paso es controlar el inicio y detención del servicio con los ítems restantes como se
muestra a continuación:
Para verificar el funcionamiento cargar a la tarjeta PIC USB el archivo SERVICIO.HEX contenido en
la carpeta HEX del CD, Se enviara el carácter “2” al presionar el botón BOOT.
Para correr la aplicación presionar la tecla menú del dispositivo y seleccionar Iniciar:
Aparecerá una notificación indicando que el servicio ha iniciado, luego seleccionar Conectar y
elegir el dispositivo Bluetooth:
184
Aparecerá un mensaje Toast indicando que se ha establecido la conexión, y al presionar el botón
BOOT de la tarjeta PIC USB aparecerá una nueva notificación:
185
AJUSTES DE MODULO BLUETOOTH
Los dispositivos Bluetooth poseen un juego de instrucciones para configurar ciertos parámetros
como el nombre o ID, Password, BaudRate, Modo, etc. Varían según la versión de firmware de
cada fabricante, algunos necesitan cierta secuencia de activación y desactivación de pines para
ingresar al modo comando, el módulo HC-06 solo necesita que se especifique los parámetros
usando comandos AT a través de la UART:
En el disco se incluyen 3 ejemplos que cambian el ID, Password y BaudRate del módulo bluetooth,
quedando como ID=”linvor”, Password=0000 y BaudRate=115200, los archivos para descargar a la
tarjeta PIC USB se encuentran en la carpeta HEX nombrados como BLUETOOTH_NAME.hex,
BLUETOOTH_PASSWORD.hex y BLUETOOTH_BAUD.hex , también se proporciona el código fuente
en la carpeta APLICACIONES PIC con los mismos nombres pero con extensión .c
Cambiar el nombre
Para cambiar el nombre se utiliza el comando AT+NAME y se envía a través de una instrucción
Printf, el comando queda como se muestra a continuación:
printf("AT+NAMElinvor");
El nombre debe ir inmediatamente después del comando, por ejemplo si se desea cambiar el
nombre a Android el comando quedara de la siguiente manera:
printf("AT+NAMEAndroid");
Cambiar el PassWord
Para cambiar el Password se utiliza el comando AT+PIN, el comando queda como se muestra a
continuación:
printf("AT+PIN0000");
Se requieren 4 digitos y deben ir inmediatamente después del comando, por ejemplo si se desea
cambiar el Password a 2012 el comando quedara de la siguiente manera:
printf("AT+PIN2012");
Cambiar el BaudRate
Para cambiar el BaudRate se utiliza el comando AT+BAUD, el comando queda como se muestra a
continuación:
printf("AT+BAUD8");
186
Se requieren 1 digito para establecer el BaudRate y debe ir inmediatamente después del comando,
para cambiar el BuadRate se tiene las siguientes opciones:
Por ejemplo si el BaudRate se quiere cambiar a 19200 el comando quedara de la siguiente manera:
printf("AT+BAUD5");
187
ANDROID USB HOST + ARDUINO UNO
Desde la versión 3.0 de Android (Honeycomb) se implementó la función de USB HOST en el
sistema, es posible escribir un driver en una aplicación para reconocer convertidores de SERIE a
USB con chips FTDI como el integrado en un arduino uno y de esta forma establecer una interfaz.
SINGLE BOARD COMPUTERS + ANDROID
Las SBC son computadoras en una sola tarjeta y de bajo costo dotadas con salidas de video, USB,
RED, entrada para periféricos, etc. El sistema operativo se instala por medio de la memoria SD, sus
prestaciones son similares a los Smartphone de media gama o hasta la potencia de una tablet de
gama alta, Existe una gran variedad de tarjetas ya disponibles y varias versiones de sistemas
operativos como Android y Linux. Entre las SBC destaca la Raspberry pi, la Gooseberry, la Beagle
Bone, etc.
188
GOOGLE ADK
Google ha desarrollado y liberado un protocolo llamado ADK (Accesory Development Kit) para el
desarrollo de accesorios para dispositivos con Android 2.3.4 o superior (Gingerbread), Una tarjeta
como USB HOST intercambia datos con un dispositivo Android para establecer una interfaz.
Existen varias tarjetas ya disponibles como PIC24F starter kit de Microchip, Google ADK de RT,
IOIO (actualizando firmware ADK), Incluso el USB HOST SHIELD para arduino.
OPENCV + ANDROID
OpenCV es una libreria para el tratamiento de imagenes, puede ser integrada en dispositivos
Android, para ello se requiere trabajar a un nivel más bajo es decir desarrollar aplicaciones nativas
con el Android NDK.
ANDROID + NFC
189
Desde la versión 4 de Android (Ice Cream Sandwich) se implementó el NFC (Near Field
Communication) que es un sistema de comunicaciones de corto alcance que permite el
intercambio de datos entre dispositivos, los protocolos están basados en RFID, algunas
aplicaciones son el pago de servicios, identificación de objetos, intercambio de archivos, etc.
APPLE MFI
Para desarrollar accesorios o algún hardware para dispositivos de Apple el desarrollador se debe
registrar en el programa MFI de Apple para acceder a la documentación de sus dispositivos,
Existen varias formas de establecer interfaces con dispositivos de Apple por ejemplo a través de
Wifi utilizando algún Shield para arduino o el transceiver MRF24WB0MA, también desde el
conector Doc de Apple, o a través de Bluetooth utilizando alguno de los módulos compatibles que
ya integren el coprocesador de Apple para vincularse como el BT-11M de Amp’ed o el PAN1321 de
Panasonic.
190
Descripción: funciones bit a bit
Objeto: Bit
Propiedades:
Not (N como Int) como Int
Devuelve el complemento bit a bit de un valor dado.
Or (N1 como Int, N2 como Int) como Int
Devuelve el OR bit a bit de los dos valores.
ParseInt (valor como String, Radix como Int) como Int
Analiza el valor como un entero usando la base especificada. Radix - debe estar entre 2 a 36.
ShiftLeft (N como Int, Shift como Int) como Int
Desplaza N turnos a la izquierda.
Shift - número de posiciones a desplazar.
ShiftRight (N como Int, Shift As Int) como Int
Desplaza N turnos a la derecha.
Mantiene valor del 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
Devuelve el ángulo medido en radianes.
ASinD (Value como Double) como Double
192
Devuelve el ángulo medido en grados.
ATan (Value como Double) como Double
Devuelve el ángulo medido en radianes.
ATanD (Value como Double) como Double
Devuelve el ángulo medido en grados.
BytesToString (Data () como Byte, StartOffset como Int, longitud como Int, CharSet como String)
Decodifica las matrices de bytes dado como una cadena. Datos: la matriz de bytes. StartOffset:el primer byte para leer. Longitud: número de bytes que leer.
CharSet - el nombre del juego de caracteres.
Ejemplo:
Dim s As String s = BytesToString (Buffer, 0, Buffer.Length, "UTF-8")
cE como Double
Constante e (base de logaritmo natural). CharsToString (Chars() como Char, StartOffset como Int, Length como Int) como String
Crea una nueva cadena copiando los caracteres de la matriz.
Comienza desde StartOffset y el número de caracteres a copiar equivale a la longitud. Chr (UnicodeValue como Int) como Char
Devuelve el carácter que está representado por el valor unicode determinado. Continue
Detiene la ejecución de la iteración actual y continúa con el siguiente. Cos (Radians como Double) como Double
Calcula la función trigonométrica coseno. Ángulo medido en radianes.
CosD (Degrees como Double) como Double
Calcula la función trigonométrica coseno. Ángulo medido en grados.
193
cPI como Double
Constante PI. CRLF como String
Carácter de nueva línea. El valor de chr (13).
Density como Float
Devuelve la escala del dispositivo, que es DPI / 160. (DPI significa puntos por pulgada).
Dim
Declara una variable.
DipToCurrent (Length como Int) como Int
Escala el valor, que representa una longitud específica en un dispositivo de densidad predeterminada (densidad = 1.0), al dispositivo actual.
Por ejemplo, el siguiente código establece el valor de ancho de este botón para tener el mismo tamaño físico
en todos los dispositivos.
Button1.Width = DipToCurrent (100)
Exit
Se cierra el bucle más interno.
ExitApplication
Inmediatamente termina la aplicación y detiene el proceso. La mayoría de las aplicaciones no usan este método y prefieren Activity.Finish que permite que el sistema operativo decida cuando asesinar el proceso.
False como Boolean
File como File
Metodos relacionados con archivos.
Floor (Number Double) como Double
Devuelve el Double más grande que es menor o igual al número especificado y es igual a un entero.
194
For
Sintaxis:
For variable = valor1 To valor2
GetDeviceLayoutValues como LayoutValues
Devuelve los valores de Layout del dispositivo
Ejemplo:
Log(GetDeviceLayoutValues)
GetType (object como Object) como String
Devuelve una cadena que representa el tipo del objeto java.
If
Sintaxis:
If condición then Declaración
Else Declaración
End If InputList (Items como List, Title como String, CheckedItem como Int) como Int
Muestra un cuadro de diálogo modal con una lista de elementos y RadioButton. Pulsando sobre un elemento se cerrará el cuadro de diálogo.
Devuelve el índice del elemento seleccionado o DialogResponse.Cancel si el usuario presiona el botón Back.
List - elementos para mostrar. Title - Título del diálogo.
CheckedItem - el índice del elemento que será seleccionado por default. Usar -1 si ningún elemento debe ser preseleccionado.
InputMultiList (elementos como lista, título como String) como List
Muestra un cuadro de diálogo modal con una lista de elementos y CheckBox. El usuario puede seleccionar varios elementos. El cuadro de diálogo se cierra pulsando sobre el botón OK
Devuelve una lista con los índices de los elementos seleccionados. La lista está ordenada. Devuelve una lista vacía si el usuario ha presionado la tecla back.
IsBackgroundTaskRunning (ContainerObject como Object, TaskId como Int) como Boolean
Comprueba si una tarea en segundo plano, presentada por el objeto contenedor y con el id especificado, se está ejecutando.
195
IsNumber (Text como String) como Boolean
Comprueba si la cadena especificada puede analizarse de forma segura como un número.
LastException como Exception
Devuelve la última excepción que fue capturada (si existe tal excepción).
LoadBitmap (Dir como String, FileName As String) como Bitmap
Carga el Bitmap.
Tener en cuenta que el sistema de archivos Android distingue mayúsculas de minúsculas. Se debe considerar el uso de LoadBitmapSample si el tamaño de la imagen es grande.
El tamaño real del archivo no es relevante, normalmente se almacenan imágenes comprimidas.
Ejemplo:
Activity.SetBackgroundImage (LoadBitmap (File.DirAssets,"SomeFile.jpg"))
LoadBitmapSample (Dir como String, 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/