AppInventor

¿Qué es AppInventor?
App Inventor parte de una idea conjunta del Instituto Tecnológico de Massachusetts y de
un equipo de Google Education. Se trata de una herramienta web de desarrollo para
iniciarse en el mundo de la programación. Con él pueden hacerse aplicaciones muy
simples, y también muy elaboradas, que se ejecutarán en los dispositivos móviles
con sistema operativo Android.
App Inventor es un lenguaje de programación basado en bloques (como piezas de un juego
de construcción), y orientado a
eventos. Sirve para indicarle al “cerebro” del dispositivo móvil qué queremos que haga, y
cómo.
Consideraciones:
1. Crear una cuenta Google
2. 2. Instalar App Inventor 2
3. 3. Instalar MIT AI2 Companion en el dispositivo Android, o conocer el emulador
4. 4. Crear una aplicación e instalarla.
App Inventor sin conexión(offline) versión Ultimate
Para esto Krupong ha desarrollado a partir de los fuentes de MIT App Inventor una
versión de la herramienta que no necesita conexión a Internet y además podremos
llevarla de manera cómoda en un dispositivo
Verificar que versión de Windows tenemos

Esta versión de App Inventor

funciona para sistemas Microsoft
Windows pero necesitamos tener
claro antes de descargarla por su
peso la versión del sistema donde
la ejecutaremos.

Si no tienes claro si tu Windows es

de 32 bits o 64 bits una manera
sencilla de averiguarlo es a través
del Panel de Control, sistema o de
manera más simple en Windows
10, haciendo clic con el botón
https://sourceforge.net/projects/ai2u/files/ai2u%204.6/Portable/AI2U-portable-v4.6-32bit.zip/download
derecho en Equipo.
https://sourceforge.net/projects/ai2u/files/ai2u%204.6/Portable/AI2U-portable-v4.6-64bit.zip/download
Iniciando App Inventor 2 Ultimate
Iniciando App Inventor 2 Ultimate

Una vez que tengamos la certeza que todo está en ejecución para poder comenzar a
trabajar desde la ventana anterior haremos clic en Start Invent o directamente en
nuestro navegador accederemos a la dirección http://localhost:8888

Una pantalla de bienvenida debe

aparecernos con el formulario de
inicio de sesión para que podamos
introducir nuestro usuario y
contraseña; haremos clic en "Click
here to use your Google Account
to login" aunque no dispongamos
de conexión a Internet o nuestra
dirección de correo sea ficticia.
Iniciando App Inventor 2 Ultimate
Configurar el idioma App Inventor

nos muestra inicialmente el interfaz en inglés, sin embargo, podemos utilizarlo también en
castellano. La elección del idioma se hace pulsando sobre el icono de la bola del mundo
situado en la esquina superior derecha de la página de App Inventor.

La pantalla que estamos viendo se divide en partes:

1- A la izquierda están los objetos que vamos a usar para diseñar la pantalla de nuestra
aplicación. Botones, imágenes, dibujos, etc. Es como la paleta de un pintor

2 centro: Representa la pantalla del móvil, y sirve para DISEÑAR el aspecto de la aplicación.
La llamada “Visor”

3 Después explicaremos la parte derecha

 SALTA
1 2
3 4
Arriba a la izquierda hay un botón importante: Conectar.

Para poder probar cómo funciona lo que vamos haciendo necesitamos transferirlo a un
móvil, o usar el emulador incluido en App Inventor (esta opción es menos
recomendable). SALTA
EJEMPLO:
El Programa consiste en la conexión
vía bluetooth desde Android al
Arduino, y que cuando oprima el
SALTA
botón ON
se enviara el numero 1 y cuando
oprima el botón OFF se enviara el
numero 2,.

El botón CONECTAR BT se usara para

que seleccione el modulo Bluetooth
conectado al Arduino. Programa que
debe cargar en el Arduino:
1 – Ingresar en la pagina http://ai2.appinventor.mit.edu

SALTA
2 – Ingresar a bloques http://ai2.appinventor.mit.edu

SALTA
¿Por qué Arduino?

Arduino también simplifica el proceso de trabajo con microcontroladores, pero ofrece

algunas ventajas para profesores, estudiantes y aficionados interesados sobre otros sistemas:

• Barato: Las placas Arduino son relativamente baratas comparadas con otras SALTA
plataformas microcontroladoras. La versión menos cara del modulo Arduino puede ser
ensamblada a mano, e incluso los módulos de Arduino preensamblados cuestan menos de 50$.

• Multiplataforma: El software de Arduino se ejecuta en sistemas operativos Windows,

Macintosh OSX y GNU/Linux. La mayoría de los sistemas microcontroladores están limitados a
Windows.

• Entorno de programación simple y claro: El entorno de programación de Arduino es fácil

de usar para principiantes, pero suficientemente flexible para que usuarios avanzados
puedan aprovecharlo también.
Para profesores, está convenientemente basado en el entorno de programación Processing, de
manera que estudiantes aprendiendo a programar en ese entorno estarán familiarizados con el
aspecto y la imagen de Arduino.

Processing es un lenguaje de programación y entorno de desarrollo

integrado de código abierto basado en Java, de fácil utilización, y que sirve
como medio para la enseñanza y producción de proyectos
Precauciones sobre el uso de la placa.

Diagrama de Pines(PinOut)

SALTA
Precauciones sobre el uso de la placa.
Diagrama de Pines(PinOut)

Modulo Bluetooth
El hardware que compone el dispositivo Bluetooth está
compuesto por dos partes:
Un dispositivo de radio, encargado de modular y transmitir SALTA
la señal. Un controlador digital, compuesto por una CPU, un
procesador de señales digitales (DSP – Digital Signal
Processor) llamado Link Controller (o controlador de Enlace)
y de las interfaces con el dispositivo anfitrión.

Los dispositivos BlueTooth pueden actuar como Masters o

como Slaves.

La diferencia es que un BlueTooth Slave solo puede

conectarse a un master y a nadie más, en cambio un master
BlueTooth, puede conectarse a varios Slaves o permitir que
ellos se conecten y recibir y solicitar información de todos
ellos,
Comunicaciones y
Apps en Android.

SALTA
Plataforma Software Arduino

Estructura de un sketch en Arduino

SALTA
Plataforma Software Mblock

LOS BLOQUES

1 SALTA

3 4 Escenario (1)
2 Bloques(2)
Espacio de
construcción de
programa(3)
Codigo del
5 programa(4)
Interfases de
uso(5)
Utilizaremos la siguiente conexión para enviarle un HIGH Y UN LOW al LED

Programa int led=13;

int estado=0;
SALTA
void setup(){
Serial.begin(9600);
pinMode(led,OUTPUT);
}

void loop(){

if(Serial.available()>0){
estado = Serial.read();
}
if (estado =='1'){
digitalWrite(led,HIGH);
}
if(estado=='2'){
digitalWrite(led,LOW);
}
}
Crear una aplicación para dibujar

Para crear una aplicación

SALTA

Una vez dentro, cambiaremos el nombre de la pantalla Screen1 por Dibujar

Crearemos un botón ,y cambiaremos su propiedad Texto por “Rojo”, y luego
pondremos en rojo su propiedad ColorDeFondo .

SALTA
Crearemos después otro botón verde, y finalmente otroazul
Para que estén en misma línea horizontal, vamos a recolocarlos en la pantalla añadiendo
un componente DisposiciónHorizontal .

SALTA

Para que se ajuste al ancho de la pantalla del visor propiedad Ancho egiremos la
opción Ajustar al contenedor...
Ahora añadimos el lienzo, arrastrando al Visor el componente Lienzo

SALTA
AppInventor utiliza el sistema cartesiano para determinar la posición de un punto
determinado dentro de un lienzo. La x aumenta desde la izquierda a la derecha, y la y lo
hace desde arriba hacia abajo.

SALTA

Al dejar quieto el puntero del

ratón sobre el icono de la x
del bloque mostaza nos
saldrá una ventanita en la que
aparecerá un pequeño bloque
tomarx de color naranja.
Tenemos que arrastrarlo hasta
encajarlo con el hueco superior
del bloque morado
llamar.Lienzo1.DibujarCírculo
Haremos lo mismo con la y . Esto hará que el círculo se dibuje sobre la x y la y que
estamos tocando, y no en cualquier otro punto de la pantalla.

La r : Indica el tamaño del círculo que vamos a dibujar, su radio .

Para definir el tamaño, el radio, abrir el cajón Matemáticas de la zona de bloques y arrastrar el
bloque azul que indicar el valor0(cero)hasta el hueco r de nuestro bloque morado. SALTA

Queremos que los

círculos se vean bien, así
que le asignaremos a r el
valor 10.
Utilizaremos el bloque

cuando.boton_rojo.Clic
cuando.boton_Azul.Clic
cuando.boton_Verde.Clic

Para dibujar con los colores de la siguiente manera: SALTA

Se utilizara ademas el bloque poner.Lienzo1.ColorDePintura.como

Duplicar botón “Color”

SALTA

Nuevo botón “Limpiar”

Dibujar circulos “Arrastado”

SALTA

Dibujar Lineas “Arrastado”

Cambiar el tamaño del pincel con un Deslizado

SALTA
Tenemos que indicarle ahora a nuestro programa que modifique el ancho de la línea de nuestro
dibujo según variemos la posición de Tamaño pincel .

Para ello, utilizaremos el bloque mostaza cuando.Tamaño_pincel.PosiciónCambiada , que se

ejecuta cada vez que se cambia la posición del selector dentro del deslizador

SALTA
 Este bloque incluye una variable, posiciónDelPulgar , que contiene el valor actual de
la posición, y que puede utilizarse para nuestro propósito.

SALTA

Elegiremos en este caso el bloque tomar , y lo combinaremos con el bloque verde del objeto Lienzo que define el ancho de
línea de dibujo, para indicar al programa que cambie el ancho de la línea cada vez que arrastremos el puntero del deslizador
Tamaño_pincel a un nueva posición.
Guardar un archivo con el dibujo que hemos hecho

El bloque de código que usaremos, incluido dentro del cajón

Lienzo, será llamar.Lienzo1.Guardar

SALTA
Guardar un archivo con el dibujo que hemos hecho

SALTA

Guardar un archivo con el dibujo que hemos hecho con un nombre:

Compartir un archivo con el dibujo que hemos hecho

El botón de compartir tomará el nombre de la variable global definida previamente. En

Ejecutamos el método CompartirArchivo de Compartir, e indicamos el archivoque ha sido
guardado en el directorio . Debemos añadirle el .png al final.
SALTA
Componentes ImageSprite y Pelota

Un recurso muy importante disponible en App Inventor es el componente SpriteImagen ,

que se encuentra en la paleta de diseño, dentro del cajón Dibujo y animación.

SALTA

SpriteImagen es un componente muy interesante para crear

juegos en los que queramos incluir y manejar objetos gráficos.

Pelota es un tipo específico dentro del conjunto SpriteImagen .

La única diferencia es que en el caso del componente Pelota no
podemos cambiar suaspecto,
La imagen del objeto, que siempre será una circunferencia. Sí
podremos hacerlo sin embargo para cualquier otro SpriteImagen

En general, un sprite es una imagen en dos dimensiones, más o menos pequeña, incluida dentro de un escenario más
grande, y que ocupa un lugar en la memoria gráfica del ordenador. Se utiliza tradicionalmente para la programación de
juegos.
Definición del escenario de juego
Comenzaremos un nuevo proyecto y le daremos un nombre descriptivo, como
“Aplastabichos”.
Empezaremos creando el lienzo Escenario
SALTA

Incluiremos un componente
Pelota , que llamaremos
spritePelota .
En el Diseñador la altura y la
anchura del escenario se
ajusten automáticamente al
contenedor. En cuanto a
las propiedades de la pelota,
definiremos que su Radio es
15, para que se vea
suficientemente grande en el
escenario.
Definición del escenario de juego
Para que el escenario siempre ocupe todo el espacio de la pantalla del dispositivo
debemos definir algunos bloques dentro del bloque mostaza cuando.Screen1.Inicializar

SALTA
Definición del escenario de juego
Tenemos que adaptar el escenario a los límites de la pantalla, tomando las propiedades de
ancho y largo de la pantalla de cada dispositivo. Además, evitaremos que la pantalla rote
automáticamente poniendo el valor de la propiedad OrientaciónDeLaPantalla a 1.

SALTA

Definir el objetivo del juego

Como decíamos antes, este juego consistirá en ir aplastando con nuestra pelota todos los objetos que aparezcan a lo
largo y ancho del escenario. Para que la pelota ruede por el escenario tendremos que inclinar el dispositivo.
La pelota rodará siempre hacia la parte del escenario que se encuentre más cerca del suelo. Recogeremos cada objeto
cuando la pelota choque con él.
El movimiento de la pelota
Esta parte es muy importante, ya que de ella depende que el juego funcione
correctamente y su uso sea agradable para el usuario. Aunque parezca complicado,
una vez entendida la lógica, no será difícil crear los bloques que permitan este
movimiento.
SALTA

Lo primero que debemos hacer

es incluir en nuestro visor un
componente Acelerómetro .
Lo llamaremos Inclinación .

Este componente no es visible,

así que aparecerá en la parte
inferior del Visor, en la zona
destinada a componentes no
visibles.
El movimiento de la pelota
Ahora utilizaremos el bloque cuando.Inclinación.CambioEnAceleración para mover la
pelota.

SALTA

Este bloque incluye tres variables, cada una de las cuales almacena la inclinación del objeto en uno de los ejes de
coordenadas. Vamos a hacer que la pelota tenga una dirección dependiendo de los valores de estas tres variables.
El movimiento de la pelota
Dentro de la tabla, en la columna de izquierda, colocaremos tres etiquetas con la descripción de
cada campo, E_nombre_acelX , E_nombre_acelY y E_nombre_acelZ .
En la columna de la derecha pondremos tres etiquetas E_valor_acelX , E_valor_acelY y
E_valor_acelZ , para mostrar las variables cuyo valor queremos conocer.
SALTA
El movimiento de la pelota
Utilizaremos el bloque cuando.Inclinación.CambioEnAceleración . Para conocer la aceleración
en el ejeX,por ejemplo, tenemos que dejar el puntero del ratón inmóvil durante un segundo
sobre el campo xAccel color naranja que hay dentro del bloque mostaza.Una vez aparezcan las
opciones tomar y poner para esa variable, podremos arrastrar el bloque tomar hasta el hueco
disponible a la derecha del bloque color verde oscuro correspondiente. SALTA
El movimiento de la pelota
usaremos el bloque violeta llamar.spritePelota. MoverA , que sirve para colocar el objeto en
cualquier punto del escenario que queramos.
Este bloque acepta dos parámetros de entrada, X e Y, que definen las coordenadas donde se
colocará la esquina superior izquierda del sprite de la pelota.
SALTA
Haremos que la coordenada X y la coordenada Y de la pelota que definen su colocación en el
escenario vayan variando cuando inclinemos el dispositivo en cualquiera de los dos ejes, o en los
dos al mismo tiempo.
Lo haremos simplemente
sumando el valor de la variable
xAccel al valor de la
coordenadaX actual de la
pelota, y sumando yAccel al
valor de la coordenada Y.
Los bloques de color verde
claro están dentro del cajón
de propiedades de
spritePelota
 El movimiento de la pelota
Cuando hagamos esto veremos que el comportamiento vertical, el de la coordenadaY, será el
esperado, es decir, que la pelota caerá hacia nosotros cuando inclinemos el dispositivo hacia
nuestro lado, y se alejará de nosotros cuando inclinemos el móvil en la dirección contraria.
Sin embargo, cuando inclinemos el dispositivo hacia la derecha, en el eje X, la pelota caerá
hacia la izquierda, y viceversa. SALTA

Para solucionar este problema, y adaptar el funcionamiento al comportamiento natural de una pelota, tendremos que modificar
el bloque que indica el posicionamiento en la componenteX de la coordenada. En lugar de sumarle el valor de xAccel le
sumaremos el valor de restar xAccel a 1.
Crear los bichos a aplastar

Para empezar habrá que dibujar el sprite que queremos utilizar en el juego para representar al
bicho que queremos aplastar.

SALTA

A continuación, y desde la ventana

del Diseñador, incluiremos en
nuestro escenario cinco objetos
SpriteImagen iguales.

usaremos el pequeño sprite de

30x30 pixels

Podemos llamarles Sprite_enemigo_1 a Sprite_enemigo_5.

Manejo de los enemigos

Una vez creados los cinco objetos tenemos que colocarlos en el escenario. Lo haremos con
el bloque llamar.Sprite_enemigo_1.MoverA

Especificaremos para cada objeto una posición aleatoria. Con los bloques azules entero
aleatorio entre definiremos en qué coordenada X aparecerá la esquina superior del SALTA
sprite dentro del escenario.

Especificaremos un 0 para indicar que el objeto puede aparecer desde el margen izquierdo
del escenario.

A continuación le diremos con el bloque verde Escenario.Ancho que el límite máximo es el límite derecho del escenario.
Manejo de los enemigos

Pero, atención, si el bloque azul entero aleatorio entre nos devolviera precisamente un
valor de X muy cercano al límite derecho la mayor parte del enemigo sobrepasaría el
límite derecho del escenario, y no sería visible. Para solucionar esto se resta a
Escenario.Anchoel ancho del sprite del enemigo, Sprite_enemigo_1.Ancho SALTA

Haremos lo mismo con la

coordenada vertical Y, y
repetiremos los mismos bloques
cinco veces, porque hay cinco
objetos iguales.
Procedimiento para tareas definidas y repetitivas

Cada vez que el juego se reinicie tendremos que colocar los objetos en el escenario, y
deberemos volver a usar todos estos bloques, así que lo mejor, para no tener que escribir el
mismo código varias veces cuando es tan grande, será definir un procedimiento, donde
incluiremos todos los bloques que sirven para colocar los objetos. SALTA

El bloque para definir

procedimientos se encuentra
dentro del cajón Procedures
Procedimiento para tareas definidas y repetitivas

Una vez definido el procedimiento, y modificado su nombre, los bloques quedarán así.

SALTA

En este caso haremos que

se ejecute el
procedimiento dentro del
bloque
cuando.Screen1.Inicializar
ejecutar.
Implementar la mecánica del juego

El jugador deberá inclinar el dispositivo para guiar a la pelota hacia cada uno de los objetos
y chocar con ellos. Cada vez que eso suceda deberemos retirar el objeto del escenario. El
juego acabará cuando el jugador haya hecho desaparecer todos los objetos.
SALTA

Para saber cuándo la pelota choca con un

objeto utilizaremos el bloque cuando
spritePelota.EnColisión Con otro ejecutar.
Este boque está dentro del cajón de recursos
relacionados con el objeto spritePelota.
Implementar la mecánica del juego

usaremos el bloque genérico poner SpriteImagen.Visible del componente como. Este bloque
nos permitirá cambian el valor de la propiedad Visible de cualquier componente del tipo
SpriteImagen, que especificaremos en el hueco del componente
SALTA

Usaremos el parámetro otro del bloque mostaza que hemos añadido

antes para indicar a qué objeto concreto queremos referirnos, y
estableceremos a falso el valor de la propiedad Visibledel objeto, para
que desaparezca del escenario.
Gestión del marcador

Tenemos también que mantener un contador de objetosrestantes, para saber cuándo se han
recogido todos y dar por completada la misión. Para ello usaremos dos variables,
v_objetos_totales, y v_objetos_restantes.
La primera define el número de objetos que vamos a manejar en cada partida, y la segunda SALTA
define el número de objetos que quedan por hacer desaparecer.
Como siempre, par indicar que estamos definiendo una variable, y que luego sea más fácil
identificarla como tal, comenzaremos los nombres con el prefijo v_

Cada vez que la pelota

choque con un objeto,
tendremos que restar 1 al
número de objetos
restantes. Cuando la variable
v_objetos_restantes sea 0,
significará que el jugador ha
recogido todos los objetos, y
el juego habrá terminado.
Gestión del marcador

Podemos añadir un chivato debajo del escenario para saber cuál es el contenido de la variable
v_objetos_restantes. Así sabremos si nuestro juego está gestionando correctamente esta
variable tan importante.
SALTA
Reorganizando los bloques de código

Cuando una aplicación está empezando a crecer, como la nuestra, conviene mirarla un poco
“desde lejos” y pensar de qué manera podemos hacer que sea más fácil de manejar, cómo
organizarla mejor. Así pues, para facilitar el mantenimiento de nuestro programa, y su lectura,
vamos a definir dos procedimientos: Iniciar_juego y Fin_del_juego. SALTA
Para ellos abriremos el cajón Procedimiento y arrastraremos dos veces el bloque como
procedimiento ejecutar
Reorganizando los bloques de código

En el primero de ellos tendremos que reubicar los objetos, y reiniciar todas las variables que
tiene que manejar el juego. Es decir, dejar las cosaslistas para empezar a jugar.

SALTA

Vemos que el procedimiento Fin_del_juego aún está vacío, pero ya sabemos que
incluiremos en él los bloques que deberán ejecutarse cuando el juego termine.
Reorganizando los bloques de código

Habrá que hacer una llamada al procedimiento Iniciar_juego dentro del bloquec cuando
Screen1.Inicializar ejecutar, que ahora quedará así.

SALTA
Limitar el tiempo para crear tensión

Para dar mayor interés al juego usaremos un temporizador, un componente Reloj, que limitará
el tiempo que tiene el jugador para aplastar a los enemigos. Cuando el tiempo termine, el
jugador no podrá eliminar más objetos.
Tenemos que empezar por crear un objeto Reloj en el Diseñador. El componente Reloj se SALTA
encuentra dentro del cajón Sensores. Le daremos el nombre Cada_Segundo. Se pretende
conocer cuándo pasa cada segundo, así que su propiedad IntervaloDelTemporizador contendrá
el valor 1000 (1000 milisegundos es igual a 1 segundo).

La idea es mostrar siempre en la pantalla el número de segundosrestantes, y para eso necesitamos restar un segundo cada
vezrespecto de la cantidad que queda disponible. Así pues, definiremos el número de segundos disponibles con la variable
v_segundos_restantes, y le daremos el valor inicial 30. En el bloque cuando.Cada_segundo.Temporizador ejecutar
indicaremos que reste 1 a la variable v_segundos_restantes, y que lo muestre en un nuevo objeto de tipo Etiqueta que
llamaremos E_segundos_restantes. Con estos componentes que hemos definido controlaremos el tiempo de juego.
¿Cuándo termina el juego?

Cuando esta variable v_segundos_restantes alcance el valor 0 (cero) la partida habrá terminado,
porque ya no habrá segundos restantes. Podemos implementar esta comprobación añadiendo
un bloque mostaza si-entonces dentro del bloque cuando.Cada_segundo.Temporizador ejecutar.
Cuando se cumpla la condición del si-entonces habrá llegado el momento de hacer una llamada SALTA
al procedimiento Fin_del_juego
¿Cuándo termina el juego?

¿En qué otro caso deberá considerarse el juego terminado? Claro, el juego también deberá
terminar cuando no queden más objetos por recoger. Lo indicaremos con un bloque si-entonces
dentro del bloque cuando.spritePelota.EnColisiónCon.ejecutar
SALTA
Fin del juego

Tenemos entonces que definir qué hacer cuando el juego termine. Una opción sencilla y clara
puede ser informar al usuario a través de un texto, y tal vez un sonido. Por ejemplo, podemos
escribir el texto “Fin del juego” en la etiqueta E_segundos_restantes. Para ello abriremos el
cajón Texto del editor de bloques, y arrastraremos el componente de texto vacío al hueco verde
SALTA
que asigna un valor al texto de la etiqueta E_segundos_restantes

Haciendo clic entre las comillas

podremos definir el texto que se
mostrará.
Fin del juego
Si ponemos mucha atención veremos que el texto aparece, pero sólo durante un segundo. Esto
se debe a que el programa comprueba en el bloque cuando.Cada_segundo.Temporizador
ejecutar si la variable Segundos_totales vale 0, pero esto sólo se cumple durante un segundo,
porque el tiempo sigue contando, así que rápidamente el valor de v_segundos_restantes pasa a
ser -1, que es el valor que se obtiene cuando a 0 le restamos 1. El programa sigue ejecutándose, SALTA
y en la siguiente ejecución del bloque cuando.Cada_segundo.Temporizador ejecutar volverá a
escribir el valor del contador de segundos encima del texto.

Para evitar esto tenemos que hacer

que Cada_segundo deje de contar,
es decir, que el bloque
cuando.Cada_segundo.Temporizad
or ejecutar deje de ejecutarse. Esto
se consigue dándole el valor falso a
la propiedad
TemporizadorHabilitado del
componente Cada_segundo
Fin del juego
Pero atención, si queremos que el programa funcione correctamente la próxima vez, y ejecute
el contenido de cuando.Cada_segundo.Temporizador ejecutar, tendremos que poner el valor de
esa propiedad como cierto en el procedimiento Iniciar_juego. Además antes deberemos
restablecer el número de segundos restantes a 30, su valor inicial. En caso de olvidarnos de dar
a nuestro programa alguna de estas dos instrucciones, el juego se ejecutaría para siempre. SALTA
Añadir un botón para empezar de nuevo
Bueno, casi está todo, pero no podemos olvidar incluir un botón “Reiniciar” para que el juego
comience de nuevo una vez terminado.

SALTA

No será difícil crear el

código necesario para
poner el juego de nuevo a
funcionar, porque hemos
sido organizados, y hemos
creado los procedimientos
adecuados. Sólo tendremos
que indicarle al programa
que ejecute el
procedimiento Iniciar_juego
cuando el jugador pulse el
botón Reiniciar
Un último detalle
En el procedimiento cuando.spritePelota.EnColisiónCon hacemos desaparecer cada objeto
cuando la pelota choca con él, usando el bloque poner SpriteImagen.Visible del componente
como. Para que los objetos vuelvan a ser visibles al pulsar el botón Reiniciar tendremos que
poner este atributo como cierto de nuevo. Podemos incluir esta instrucción, por ejemplo,
dentro el procedimiento Colocar_enemigos SALTA

Vamos a hacer esto

utilizando un bloque
disponible dentro de los
cajones de cada enemigo.
Usaremos el bloque verde
oscuro que sirve para
establecer el estado del
atributo Visible. Podemos
hacer lo mismo para
todoslos enemigos
copiando el bloque del
primero y cambiando el
nombre del enemigo al que
se refiere en cada caso.
Conexionado del módulo Bluetooth, el Arduino y el pulsador.
Arduino le envía una señal mediante Bluetooth al móvil y éste cuando lo recibe lo escribe en la
pantalla.
- Le ponemos dos pulsadores al Arduino, cuando pulsemos uno, enviará la señal
"Hola amigo" por Bluetooth al móvil, y al recibirla, éste escribirá el mensaje en su pantalla.
SALTA
- Si pulsamos el otro pulsador del Arduino, se escribirá en el móvil "Me llamo Juan".

Debemos alimentar el módulo Bluetooth y

además llevar tensión al pulsador como indica la
figura superior. Utilizamos una resistencia de 10 K
- Un pulsador irá al terminal 2 y el otro al
terminal 3 del Arduino.
- Para montarlo he utilizado una placa de
experimentación, espero que los detalles de las
fotos sean aclaratorios.
Código del Arduino.
- En este código cuando pulsemos uno de los dos botones, se enviará un texto al móvil.
Si pulsamos un Botón enviará: "Hola amigo"
Si pulsamos el otro Botón enviará: "Me llamo Juan"
char val; SALTA
int ledPin13 = 13; if (buttonState3 == HIGH) {
const int boton2 = 2; Serial.println("Me llamo Juan");
const int boton3 = 3; delay(50);
int buttonState2 = 0; }
int buttonState3 = 0; if( Serial.available() ) {/// LED 13
val = Serial.read();
void setup() { - Además también recibe
Serial.begin(9600); if( val == '0' ) información, es decir, cuando
pinMode(boton2, INPUT); { escribamos un 0 o un 1 en el
pinMode(boton3, INPUT); digitalWrite(ledPin13, LOW);
pinMode(ledPin13, OUTPUT); }
móvil y pulsemos el botón de
} enviar, se encenderá/apagará el
if( val == '1' ) LED 13, como vimos en el código
void loop(){ { anterior.
buttonState2 = digitalRead(boton2); digitalWrite(ledPin13, HIGH);
buttonState3 = digitalRead(boton3); }
if (buttonState2 == HIGH) { }
Serial.println("Hola amigo"); }
delay(50);
}
App Inventor 2 -Diseño
- El Conectar es un SelectorDeLista
- Un CampoDeTexto.
- El Reloj tiene IntervaloDeTiempo = 10

SALTA

- Escribes 0 o 1 y se apagará o encenderá el LED13 del

Arduino.
- Si pulsas un botón del Arduino, se escribirá un mensaje
en el móvil.
App Inventor 2 -Bloques.
- Cuando pulsamos el SelectorDeLista de Conectar, éste se carga con los dispositivos Bluetooth
encontrados.
- Cuando pulsamos a nuestro dispositivo Bluetooth que ha salido en la lista del SelectorDeLista,
entra el proceso de conexión.
- Se habilitan/deshabilitan controles y se envía un mensaje. SALTA
App Inventor 2 -Bloques.

- Cuando pulsamos un botón en el Arduino, se envía un texto por Bluetooth.

SALTA
App Inventor 2 -Bloques.

- El Reloj.Temporizador, está contínuamente chequeando si hay Bytes disponibles recibidos,

cada IntervaloDeTiempo = 10, hace este chequeo.

SALTA

- Así que el Reloj está continuamente en funcionamiento chequeando.

- En caso que se detecte Bytes disponibles recibidos, éstos se escriben en la Etiqueta, es el texto enviado por el Arduino.
- El Botón Borrar, borra la información del Label.
- El Botón Enviar: si escribimos en el casillero CampoDeTexto un 1 o un 0, se enviará al Arduino y se encenderá/apagará el
LED13.
App Inventor 2 -Bloques.

- El Reloj.Temporizador, está contínuamente chequeando si hay Bytes disponibles recibidos,

cada IntervaloDeTiempo = 10, hace este chequeo.

SALTA

- Así que el Reloj está continuamente en funcionamiento chequeando.

App Inventor 2 -Bloques.
- En caso que se detecte Bytes disponibles recibidos, éstos se escriben en la Etiqueta, es el texto
enviado por el Arduino.
- El Botón Borrar, borra la información del Label.
- El Botón Enviar: si escribimos en el casillero CampoDeTexto un 1 o un 0, se enviará al Arduino
y se encenderá/apagará el LED13. SALTA
App Inventor 2 -Bloques.

- El Botón Desconectar, realiza la desconexión Bluetooth.

- Como verás existe el efecto rebote, es decir el Arduino está enviando el texto durante el
tiempo de pulsado del botón, en cada pulsado envía varios mensajes correspondientes a ese
botón, efecto rebote.
SALTA

- Para solucionarlo, cambia el delay en el

código del Arduino o agrega un fin de texto a
cada mensaje y cuando lo reciba el móvil que
no admita otro hasta pasado un tiempo.