Processing, basado en el lenguaje de programación Java, está pensado para hacer más fácil el desarrollo de aplicaciones con gráficos interactivos, por lo que, en el contexto de la programación de dispositivos basados en MCU, resulta muy práctico para crear presentaciones gráficas de datos y diseñar interfaces (GUI) con los que controlar dispositivos electrónicos además de muchas otras aplicaciones.
Como ocurre con la inmensa mayoría de lenguajes y de entornos de desarrollo, Processing incluye en sus recursos básicos los componentes centrales del objetivo al que se dirige, la programación de gráficos, en su caso; y separa en librerías, propias o de terceros, los elementos menos frecuentes. Además, Processing cuenta con varios modos de programación que le permiten generar código en diferentes lenguajes y/o para diferentes plataformas.
Por su ubicuidad, los teléfonos inteligentes (smartphones) son un dispositivo excelente para realizar estas dos tareas: presentar datos y controlar dispositivos usando una interfaz gráfica de usuario (GUI).
Cuando el dispositivo electrónico basado en MCU que se va a controlar o desde el que se obtienen datos está conectado a Internet, seguramente formando parte de la IoT, la solución más sencilla suele ser implementar un sistema de control web basado en el lenguaje HTML, con estilos gráficos CSS, programación JavaScript y gráficos en formato SVG y si no existe tal conexión (pública en la IoT, o privada en una intranet) utilizar una directa por medio de Bluetooth, también muy presente en los dispositivos móviles.
La propia Processing Foundation desarrolla el modo de programación Processing para Android con el que programar para este sistema operativo, presente en una buena parte de los smartphones (más del 85 % en 2016). Desafortunadamente, las comunicaciones Bluetooth no están incluidas en este modo de programación y es necesario utilizar librerías de terceros, la librería Ketai es seguramente la más utilizada para este tipo de comunicaciones en Android; probablemente su nombre viene de la «katakanización» de la palabra portátil, con la que se hace referencia en japonés al teléfono móvil.
Además de las comunicaciones Bluetooth en Android, objeto de este artículo, la librería Ketai sirve para obtener información desde los sensores disponibles en el dispositivo, incluyendo los acelerómetros, la geolocalización GPS (o GLONASS, en su caso), las cámaras y su explotación vía reconocimiento facial y para otras comunicaciones, además de Bluetooth, como wifi o NFC.
Instalar la librería Ketai para Android en Processing
Para poder utilizar la librería Ketai en Processing es necesario disponer también del modo de programación Processing for Android, para añadirlo al PDE se puede seguir el tutorial para programar dispositivos Android con Processing, en el que se explica como instalarlo y cómo generar los APK.
Para instalar Ketai se utiliza la entrada Añadir biblioteca… que aparece al desplegar Importar biblioteca… que está dentro del menú Sketch del entorno de desarrollo de Processing (PDE). Esta operación muestra el panel de gestión de las contribuciones (los extras) de Processing denominado Contribution Manager.
En realidad, se puede llegar al panel para gestionar las contribuciones desde varias entradas del PDE y posteriormente se puede seleccionar la solapa Libraries, la que queda más a la izquierda en el panel, desde la que se manejan las librerías (Ketai, en este caso).
Para instalar la librería se selecciona de la lista, lo que mostrará información de la misma en el cuadro de la parte de abajo del panel, y luego se pulsa sobre el botón Install. Para posteriores actualizaciones se puede utilizar el botón Update o el botón Remove para desinstalarla, en todos los casos después de seleccionarla de la lista.
Una vez instalada se muestra una marca de verificación a la izquierda, en la columna Status, dentro de un círculo verde, como puede verse en la imagen de la captura de pantalla anterior.
Plantilla para comunicaciones Bluetooth con la librería Ketai
La ventaja de desarrollar aplicaciones utilizando Processing, frente a hacerlo, por ejemplo, programando directamente en Java, es poder centrarse en la creación de los gráficos interactivos (y en el procesado de los datos que los definen) y delegar a Processing las tareas de las capas del nivel inferior, las más cercanas al sistema operativo e incluso al dispositivo.
Cuando se desarrolla para diferentes plataformas esto es especialmente valioso y si se abarcan las especificidades de la plataforma, como es el caso de Android y los dispositivos móviles, aún más. En el aspecto gráfico, objetivo central de Processing, permite abstraer fácilmente la plataforma en la que se ejecuta el sketch pero en otros aspectos, precisamente los que requieren de librerías de terceros, como es el caso de la librería Ketai y las comunicaciones Bluetooth, necesita que se realice cierta gestión manual del proceso.
En concreto, para poder implementar las comunicaciones Bluetooth con la librería Ketai para el modo de programación Processing for Android es necesario atender al ciclo de vida de las actividades en Android.
Por otro lado, la librería Ketai llama al método onBluetoothDataEvent cada vez que se reciben datos desde un dispositivo Bluetooth, por lo que normalmente se definirá este método en las aplicaciones que trabajen con esta librería.
Si se unen a estas dos circunstancias, ① la gestión del ciclo de vida de las actividades en Android y ② el método para atender a la recepción de datos Bluetooth, la inclusión de la librería y de los diferentes componentes de desarrollo para Android que se necesitan para utilizarla, queda una pequeña estructura de código que se usa casi indefectiblemente cada vez que se incluyen comunicaciones Bluetooth en un programa Processing para Android. Con lo que se explica más adelante, a esta estructura se podrá añadir además la detección de dispositivos Bluetooth que estén al alcance y la conexión a ellos.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
import android.os.Bundle; // onCreate Bundle import android.content.Intent; // onActivityResult Intent import ketai.net.*; import ketai.net.bluetooth.*; // KetaiBluetooth KetaiBluetooth bluetooth; void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); bluetooth=new KetaiBluetooth(this); } void onActivityResult(int codigo_solicitud, int codigo_resultado, Intent datos) { bluetooth.onActivityResult(codigo_solicitud,codigo_resultado,datos); } void onBluetoothDataEvent(String origen, byte[] datos) { // origen contiene el identificador (MAC) del dispositivo Bluetooth del que provienen los datos // datos es un vector de bytes con la información recibida } void setup() { if(!bluetooth.isStarted()) { bluetooth.start(); } } void draw() { } void exit() { bluetooth.stop(); super.exit(); } |
Dentro del método onCreate, que se llama cada vez que se crea la actividad en Android (cuando se inicia la aplicación), se incluye la inicialización del objeto Bluetooth con KetaiBluetooth.
El objeto Bluetooth se pasa al sketch con el método onActivityResult, que se lanza automáticamente después de reanudar la actividad (realizar la llamada a onResume) y que a su vez puede ir precedido por onStart si es el primer ciclo de vida de la actividad.
Para arrancar las comunicaciones, normalmente dentro del método setup de Processing, se utiliza el método start del objeto Bluetooth que proporciona la librería Ketai. Antes de arrancar las comunicaciones se puede consultar si ya han sido iniciadas utilizando el método isStarted, que devuelve true si ya se han iniciado o false si es necesario iniciarlas.
Aunque la tendencia al usar Processing es abstraer el programa de los diferentes estados de las actividades de Android, es interesante saber que una aplicación Android llamará a estos métodos en cada fase del ciclo de vida de la actividad para poder explotarlos mientras llegan nuevas versiones del modo de programación hagan más transparente el trabajo.
En Processing suelen terminarse las aplicaciones invocando el método exit. En el código de ejemplo anterior se usa la redefinición del mismo para ilustrar el uso del método stop con el que terminar las comunicaciones Bluetooth gestionadas por la librería Ketai, aunque en Android no es frecuente implementar un recurso para terminar una actividad (en el uso habitual, simplemente pasan a segundo plano cuando no se están usando).
Estados de un dispositivo Bluetooth con respecto a otro
Desde el punto de vista del dispositivo principal, la máquina que se está programando, los otros dispositivos Bluetooth pueden encontrarse en tres estados: ① conectados, cuando ya se ha establecido una conexión Bluetooth con ellos, porque estaban dentro del alcance (cobertura) y porque se ha proporcionado una clave cuando sea necesario; ② emparejados, cuando se ha reconocido anteriormente al dispositivo (seguramente ya se había establecido antes una conexión) por lo que está listo para establecer la conexión (incluso puede haberse almacenado la clave); ③ detectable, porque se encuentre dentro de área de alcance (cobertura) y se ha configurado de forma que permite ser detectado.
Aunque un dispositivo se haya emparejado con el principal, parece lógico esperar que no se pueda realizar la conexión con él si no se encuentra disponible dentro la zona de alcance (cobertura). Por otro lado, un dispositivo puede estar dentro del área de alcance y no ser detectado porque se haya configurado de forma que no responda a las peticiones de localización, de forma que se puede conectar solo si se conoce previamente su existencia.
Detectar los dispositivos Bluetooth disponibles
Para buscar con la librería Ketai los equipos Bluetooth que se encuentran dentro del área de alcance y que se han configurado de forma que permiten ser identificados, es decir, son detectables, se utiliza el método discoverDevices, que inicia el proceso de detección con el que se va componiendo una lista de dispositivos detectables (dentro del área de alcance y que permiten ser identificados).
Como el proceso de detección puede durar unos segundos en completarse, la librería Ketai proporciona el método isDiscovering que devuelve true mientras está activo y false cuando ha terminado.
Para acceder a la lista de dispositivos que se han detectado con discoverDevices se utiliza el método getDiscoveredDeviceNames de la librería Ketai, que devuelve un ArrayList<String>. Esta lista es accesible, se puede consultar, aunque el proceso de detección no haya terminado aún.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
import android.os.Bundle; // onCreate Bundle import android.content.Intent; // onActivityResult Intent import ketai.net.*; import ketai.net.bluetooth.*; // KetaiBluetooth KetaiBluetooth bluetooth; ArrayList<String> dispositivos_bluetooth; int cronometro; void onCreate(Bundle instancia_almacenada) { super.onCreate(instancia_almacenada); bluetooth=new KetaiBluetooth(this); } void onActivityResult(int codigo_solicitud, int codigo_resultado, Intent datos) { bluetooth.onActivityResult(codigo_solicitud,codigo_resultado,datos); } void setup() { fullScreen(P2D); background(100,100,100); frameRate(1); // Cada segundo comprobará que la detección de dispositivos Bluetooth haya terminado para mostrar la lista de los que se han encontrado bluetooth.start(); cronometro=millis(); bluetooth.discoverDevices(); // Necesita permisos BLUETOOTH_ADMIN } void draw() { if(!bluetooth.isDiscovering()) { noLoop(); cronometro=(millis()-cronometro)/1000; dispositivos_bluetooth=bluetooth.getDiscoveredDeviceNames(); println("\nDispositivos encontrados (en "+cronometro+" segundos):"); for(String dispositivo:dispositivos_bluetooth) { println(dispositivo); } bluetooth.stop(); } } |
Como se explicó en el tutorial para programar dispositivos Android con Processing, dependiendo de los recursos que se utilicen, puede ser necesario que el usuario autorice el acceso; para declarar estos permisos se utiliza la entrada Sketch Permissions del menú Android, que muestra una lista con los permisos de Android con los nombres de las constantes correspondientes. En este caso será necesario seleccionar los dos niveles de permisos Bluetooth: BLUETOOTH y BLUETOOTH_ADMIN
La librería Ketai muestra mucha información para depuración. Si se atiende a la consola de Processing puede observarse cómo se van detectando los dispositivos Bluetooth y se construye la lista.
Consultar los dispositivos Bluetooth conectados o emparejados
Además de la lista de dispositivos detectados, existe una lista con los dispositivos emparejados, a la que se tiene acceso con getPairedDeviceNames y otra con los dispositivos conectados que se obtiene con getConnectedDeviceNames. En ambos casos, igual que ocurre con getDiscoveredDeviceNames, los métodos devuelven un ArrayList<String> con los nombres de los dispositivos Bluetooth.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 |
import android.os.Bundle; // onCreate Bundle import android.content.Intent; // onActivityResult Intent import ketai.net.*; import ketai.net.bluetooth.*; // KetaiBluetooth KetaiBluetooth bluetooth; ArrayList<String> dispositivos_bluetooth; int cronometro; void onCreate(Bundle instancia_almacenada) { super.onCreate(instancia_almacenada); bluetooth=new KetaiBluetooth(this); } void onActivityResult(int codigo_solicitud, int codigo_resultado, Intent datos) { bluetooth.onActivityResult(codigo_solicitud,codigo_resultado,datos); } void setup() { fullScreen(P2D); background(100,100,100); frameRate(1); // Cada segundo comprobará que la detección de dispositivos Bluetooth haya terminado para mostrar la lista de los que se han encontrado bluetooth.start(); cronometro=millis(); bluetooth.discoverDevices(); // Necesita permisos BLUETOOTH_ADMIN } void draw() { if(!bluetooth.isDiscovering()) { noLoop(); cronometro=(millis()-cronometro)/1000; dispositivos_bluetooth=bluetooth.getConnectedDeviceNames(); println("\nDispositivos conectados:"); for(String dispositivo:dispositivos_bluetooth) { println(dispositivo); } dispositivos_bluetooth=bluetooth.getPairedDeviceNames(); println("\nDispositivos emparejados:"); for(String dispositivo:dispositivos_bluetooth) { println(dispositivo); } dispositivos_bluetooth=bluetooth.getDiscoveredDeviceNames(); println("\nDispositivos encontrados (en "+cronometro+" segundos):"); for(String dispositivo:dispositivos_bluetooth) { println(dispositivo); } bluetooth.stop(); } } |
Obtener la dirección MAC los dispositivos Bluetooth
Mientras que hacer referencia a un equipo Bluetooth por su nombre puede ser más sencillo de recordar, referirse a él por su dirección MAC en más preciso, diferentes dispositivos pueden tener el mismo nombre pero, en principio, las direcciones MAC son únicas (en realidad, se pueden cambiar, así que es posible que existan duplicados).
Para saber la dirección MAC de un dispositivo Bluetooth la librería Ketai proporciona el método lookupAddressByName que toma como argumento el nombre del dispositivo y devuelve su dirección MAC.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
import android.os.Bundle; // onCreate Bundle import android.content.Intent; // onActivityResult Intent import ketai.net.*; import ketai.net.bluetooth.*; // KetaiBluetooth KetaiBluetooth bluetooth; ArrayList<String> dispositivos_bluetooth; void onCreate(Bundle instancia_almacenada) { super.onCreate(instancia_almacenada); bluetooth=new KetaiBluetooth(this); } void onActivityResult(int codigo_solicitud, int codigo_resultado, Intent datos) { bluetooth.onActivityResult(codigo_solicitud,codigo_resultado,datos); } void setup() { fullScreen(P2D); background(100,100,100); noLoop(); bluetooth.start(); dispositivos_bluetooth=bluetooth.getPairedDeviceNames(); println("\nDispositivos emparejados:"); for(String dispositivo:dispositivos_bluetooth) { println(dispositivo+", MAC: "+bluetooth.lookupAddressByName(dispositivo)); } bluetooth.stop(); } |
Conectar a un dispositivo Bluetooth
La librería Ketai ofrece dos métodos para iniciar las comunicaciones Bluetooth con un dispositivo desde Android: connectDevice, que toma como argumento la dirección MAC expresada como una cadena de texto (String) y connectToDeviceByName que espera el nombre del dispositivo Bluetooth como parámetro de entrada, también como un String.
Dependiendo de que el dispositivo con el que se establece la conexión esté o no emparejado, puede que sea necesario introducir una clave. En tal caso, Android mostrará la correspondiente notificación y el cuadro de diálogo para introducirla.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
import android.os.Bundle; // onCreate Bundle import android.content.Intent; // onActivityResult Intent import ketai.net.*; import ketai.net.bluetooth.*; // KetaiBluetooth KetaiBluetooth bluetooth; void onCreate(Bundle instancia_almacenada) { super.onCreate(instancia_almacenada); bluetooth=new KetaiBluetooth(this); } void onActivityResult(int codigo_solicitud, int codigo_resultado, Intent datos) { bluetooth.onActivityResult(codigo_solicitud,codigo_resultado,datos); } void setup() { fullScreen(P2D); background(100,100,100); noLoop(); bluetooth.start(); bluetooth.connectDevice("30:14:08:26:10:47"); // Conectar usando la MAC del dispositivo Bluetooth //bluetooth.connectToDeviceByName("Bluetooth HC-06"); // Conectar por el nombre del dispositivo } |
Ambos métodos devuelven un valor booleano que representa si se ha establecido la conexión. Como el establecimiento de la conexión no es inmediato, utilizarlos dentro de una estructura if puede resultar confuso, es preferible establecer la conexión y posteriormente, por ejemplo dentro de draw, verificar si está activa consultando la lista de dispositivos conectados con getConnectedDeviceNames.
Enviar datos a un dispositivo Bluetooth
Una vez que se ha establecido una conexión con un dispositivo ya se pueden enviar o recibir datos. La librería Ketai proporciona dos métodos que se pueden utilizar para referirse al dispositivo por su dirección MAC, write, o por su nombre writeToDeviceName. Ambos métodos esperan dos argumentos, ① la dirección MAC o el nombre, según corresponda, y ② un vector de bytes con los datos que se envían.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 |
import android.os.Bundle; // onCreate Bundle import android.content.Intent; // onActivityResult Intent import ketai.net.*; import ketai.net.bluetooth.*; // KetaiBluetooth KetaiBluetooth bluetooth; String MAC_dispositivo_destino="30:14:08:26:10:47"; byte[] mensaje={0x48,0x6F,0x6C,0x61,0x0A}; // Hola\n void onCreate(Bundle instancia_almacenada) { super.onCreate(instancia_almacenada); bluetooth=new KetaiBluetooth(this); } void onActivityResult(int codigo_solicitud, int codigo_resultado, Intent datos) { bluetooth.onActivityResult(codigo_solicitud,codigo_resultado,datos); } void setup() { fullScreen(P2D); background(100,100,100); frameRate(1); if(!bluetooth.isStarted()) { bluetooth.start(); } bluetooth.connectDevice(MAC_dispositivo_destino); } void draw() { ArrayList<String> dispositivo_bluetooth=bluetooth.getConnectedDeviceNames(); int numero_dispositivo=0; while(numero_dispositivo<dispositivo_bluetooth.size()) { if(dispositivo_bluetooth.get(numero_dispositivo).contains(MAC_dispositivo_destino)) { noLoop(); bluetooth.write(MAC_dispositivo_destino,mensaje); numero_dispositivo=dispositivo_bluetooth.size(); } else { numero_dispositivo++; } } } |
En el ejemplo anterior se consulta la lista de dispositivos conectados y se busca en ella la dirección MAC del dispositivo objetivo. En esta lista, que se obtiene con getConnectedDeviceNames, cada elemento está formado por el nombre del dispositivo y, entre paréntesis, la dirección MAC, por lo que no basta con utilizar contains para verificar si la lista contiene un elemento, antes habrá que componer un texto con el formato que utiliza la librería Ketai o bien recorrer la lista y comprobar cada elemento para comprobar si contiene la dirección MAC. Este segundo método parece un poco más seguro, por trabajar con la dirección MAC en lugar de con el nombre del dispositivo Bluetooth y porque cabe sospechar que el formato que usa getConnectedDeviceNames (sin espacios) podría cambiar en versiones futuras.
Recibir datos desde un dispositivo Bluetooth
Cada vez que llegan datos desde un dispositivo Bluetooth, con el que previamente se debe haber establecido una conexión, se llama al procedimiento onBluetoothDataEvent, que usa como argumentos ① la dirección MAC del dispositivo, para identificar el origen desde el que llegan los datos (puede haber varias conexiones activas) y ② un vector de bytes con los datos recibidos hasta el momento de producirse el evento que llama a onBluetoothDataEvent.
Como no llegarán datos hasta que la conexión solicitada no esté operativa, no es necesario verificarla, al contrario de lo que ocurre al enviar datos. Al enviar datos se pueden transmitir mensajes completos sin preocuparse de cómo los articulará el buffer (su longitud y los momentos en los que se envía); sin embargo, al recibirlos, sí que debe reconstruirse el mensaje que llega, que no necesariamente estará completo en una llamada a onBluetoothDataEvent ni necesariamente llegarán datos solamente de un dispositivo en cada llamada.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
import android.os.Bundle; // onCreate Bundle import android.content.Intent; // onActivityResult Intent import ketai.net.*; import ketai.net.bluetooth.*; // KetaiBluetooth KetaiBluetooth bluetooth; static final byte TERMINADOR_DATOS=10; String MAC_dispositivo_origen="30:14:08:26:10:47"; String mensaje=""; void onCreate(Bundle instancia_almacenada) { super.onCreate(instancia_almacenada); bluetooth=new KetaiBluetooth(this); } void onActivityResult(int codigo_solicitud, int codigo_resultado, Intent datos) { bluetooth.onActivityResult(codigo_solicitud,codigo_resultado,datos); } void setup() { fullScreen(P2D); background(100,100,100); noLoop(); bluetooth.start(); bluetooth.connectDevice(MAC_dispositivo_origen); } void onBluetoothDataEvent(String origen, byte[] datos) { if(origen==MAC_dispositivo_origen) { mensaje+=new String(datos); if(datos[datos.length-1]==TERMINADOR_DATOS) { print(mensaje); mensaje=""; } } } |
Identificar el dispositivo Bluetooth principal
En determinadas circunstancias también será necesario identificar el dispositivo principal (el que se está programando) determinando su dirección MAC y, en su caso, hacerlo detectable por otros dispositivos Bluetooth. Normalmente, Android pedirá permiso cuando el dispositivo vaya a cambiar al modo visible (detectable) para otros dispositivos Bluetooth y solamente estará activo durante un periodo de 300 segundos después del cual volverá a estar oculto (no detectable).
La librería Ketai ofrece el método getAddress para obtener la dirección MAC del dispositivo principal y los métodos isDiscoverable y makeDiscoverable para saber si el dispositivo ya es visible y para hacerlo visible en caso contrario.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
import android.os.Bundle; // onCreate Bundle import android.content.Intent; // onActivityResult Intent import ketai.net.*; import ketai.net.bluetooth.*; // KetaiBluetooth KetaiBluetooth bluetooth; void onCreate(Bundle instancia_almacenada) { super.onCreate(instancia_almacenada); bluetooth=new KetaiBluetooth(this); } void onActivityResult(int codigo_solicitud, int codigo_resultado, Intent datos) { bluetooth.onActivityResult(codigo_solicitud,codigo_resultado,datos); } void setup() { fullScreen(P2D); background(100,100,100); noLoop(); bluetooth.start(); print("La dirección del dispositivo es "+bluetooth.getAddress()); if(bluetooth.isDiscoverable()) { print("El dispositivo ya es detectable"); } else { bluetooth.makeDiscoverable(); } bluetooth.stop(); } |
Víctor Ventura
Desarrollando aplicaciones para la web conocí el potencial de internet de las cosas, encontré la excusa perfecta para satisfacer la inquietud de aprender electrónica que había tenido desde siempre. Ahora puedo darme el gusto de programar las cosas que yo mismo diseño y fabrico.
Sígueme:
Riccardo
Gracias por este artículo.
Have you tried that with Bluetooth Low Energy?
Víctor Ventura
Hi, Riccardo.
No, I didn’t try with BLE but I’m pretty shure that it will work.
I saw your nice web. I wish you a lot of luck with your project.
Kind regards.
Antonio Ruiz
Muchas gracias por el artículo.
Acabo de descubrir que con processing (descubriendola ahora) y la librería Ketai siplifica muchísimo la conexión con Arduino (plataforma en la que trabajo desde hace años), bravo por toda esta gente que lo hace poosible.
Aprovecho para preguntarte por los componentes gráficos del principio del artículo, los gauges de temperatura, también me han gustado mucho ¿Cuales son?
Un saludo,
Víctor Ventura
Hola, Antonio.
Me alegra que te haya gustado el artículo.
Los componentes gráficos que aparecen en el artículo son diseños míos que he utilizado en algunos proyectos y de los que seguramente hablaré en otro artículo.
Gracias a ti por visitar el blog ¡Hasta pronto!
Robert
Hola
Muy util el post. Es necesario todo el código para identificar los dispositivos? En mi caso, quiero que mi tablet se conecte con una Arduino en la que ya estaria transmitiendo por bluetooth y enviarle información desde la tablet corriendo Processing. O sea, podria dejarle «en duro» la MAC del receptor bluetooth de la Arduino?
Antonio
Hola Victor,
He visto que has actualizado esta publicación recientemente, he estado siguiendo el resto de publicaciones también.
¿Tienes ya disponible los componentes gráficos del comienzo del artículo?
Si no los tienes todavía disponibles para publicar ¿podrías adelantármelos?
He estado buscando Gauges para Processing para Android y no encuentro tan chulos como esos.
Un saludo,
jose
Un artículo muy bien explicado y detallado.
Mil Gracias!
Esta librería soporta el envío/recepción de un audio mp3 ?
Alguna librería que lo soporte?
Saludos y Mil Gracias