Manual de conexin Bitalino - Python.

1.0v

Federico Jensen Carrasco.



Introduccin a Bitalino.

Bitalino es un conjunto de herramientas y sensores fisiolgicos para el desarrollo de software y hardware. El

hardware tiene un formato modular todo-en-uno e integra mltiples sensores de adquisicin de bioseales, junto a un
microcontrolador especialmente diseado para la recepcin de estos datos. Adems incluye un sistema de trasferencia
inalmbrica Bluetooth y un bloque de administracin de energa. El software integrado est basado bajo el lenguaje PhP
y Python con el cual es posible graficar los datos de los sensores, tambin es posible realizar conexiones a otras
plataformas de trabajo.

Hardware

Bitalino est construido bajo un modelo modular, compuesto por 9 unidades, donde cada una cumple una
funcin especfica.

1) MCU: Es la unidad de procesamiento de datos, ella recibe de los puertos, organiza y enva los datos a la
unidad BT. Tambin es responsable de activar puertos de entrada como salidas, en caso de recibir la orden
correcta.
2) PWR: Unidad encargada de administrar la energa al dispositivo completo desde la pila recargable o el
puerto USB. Esta posee en control de encendido y apagado de la unidad.
3) BT: Esta unidad es la correspondiente al Bluetooth. Es encarga de recibir los datos del MCU y trasmitirlos
mediante su protocolo a otras unidades Bluetooth. Tambin puede recibir datos de otros Bluetooth y
enviarlos bajo el protocolo de Bitalino a la MCU.
4) EMG: Sensor capaz de detectar el cambios en el estado de un musculo gracias a la variacin en el potencial
elctrico.
5) EDA: Unidad con sensor capaz de medir el cambio en la conductividad de la piel.
6) LUX: Sensor fotoelctrico.
7) ECG: Sensor capaz de detectar las pulsaciones cardiacas gracias al cambio de potencial elctrico.
8) ACC: Unidad de acelermetro de 3 ejes. Es capaz de medir la aceleracin en un rango de -4,5g a 4,5g. La
unidad de fbrica solo trae habilitada la deteccin respecto al eje Z del dispositivo.
9) LED: Unidad que incorpora LED de alta luminosidad color blanco.

Software

Bitalino posee la caracterstica de conectarse e interactuar con muchos lenguajes de programacin

distintos. Entre ellos encontramos: Python, Java, LabView, Visual C# y Matlab. Gracias a esto podemos
interactuar con otros dispositivos como computadores Windows, telfonos Andriod (Bajo JAVA) y RaspberryPi.
En este manual veremos cmo interactuar con el lenguaje Python.


Conexin por Python

Preparando el sistema.

Para poder realizar la conexin entre Bitalino y un computador bajo el lenguaje de programacin Python es
necesario seguir los siguientes pasos.

1) Instalar Python 2.7.6 (Sobre la versin 3.0 no funciona)

Link: ( https://www.python.org/downloads/ )

2) Instalar las siguientes bibliotecas de Python (Todas las bibliotecas para la versin correspondiente, Python
2.7)
a. nunpy Link: (http://www.lfd.uci.edu/~gohlke/pythonlibs/#numpy)
b. pySerial Link: (http://www.lfd.uci.edu/~gohlke/pythonlibs/#pyserial)
c. pyBlues Link: (http://www.lfd.uci.edu/~gohlke/pythonlibs/#pybluez )

3) Descargar la API de Bitalino para Python.
Link: ( https://github.com/bitalino/bitalino-python/blob/master/bitalino/bitalino.py )

*NOTA*El archivo Python de la API tiene que estar ubicada en la misma carpeta donde estemos trabajando
nuestro proyecto.

Ocupando el cdigo de conexin por primera vez.

Para entender cmo funciona el cdigo de conexin ocupramos como base el siguiente cdigo.
LINK del cdigo: ( https://github.com/Kromtar/Bitalino/blob/master/BitalinoEjem1 )
Cree un nuevo proyecto en Python y copie el cdigo.

Antes de editar nuestro cdigo.

1) Es necesario tener instalado nuestro Bitalino en el computador, y tambin tener instalado el
programa Open Signals 3.0 (Para poder saber la MAC del dispositivo si es que no la conocemos).

Link: ( http://www.bitalino.com/anatomy-
bitalino/clkn/http/camoes.lx.it.pt/files/OpenSignals_3.0.exe )
Link Manual de Open Signals 3.0:
(http://www.biosignalsplux.com/downloads/opensignalsbit/manual.html )



2) Con Open Signals podemos conectarnos a nuestro Bitalino de forma muy fcil y graficar datos.
Tambin en las configuraciones de este programa podremos encontrar la MAC (Cdigo de
conexin) del dispositivo luego de haberlo instalado.

Tenemos que conocer la MAC de nuestro dispositivo para poder conectarnos desde Python.

Editando nuestro cdigo.

Primero necesitaremos cambiar la MAC del cdigo descargado, por la de nuestro Bitalino. Revisando el
cdigo encontraremos la siguiente informacin, donde tendremos que remplazar la existente y poner nuestra
MAC.
macAddress = "98:D3:31:B2:14:72"

Preparando el Bitalino para la primera prueba.

Encienda el Bitalino y conecte el sensor LUX (Sensor de luz) al puerto A0.

Puertos:

Ejecutando nuestro cdigo por primera vez.

Luego de cambiar la MAC ejecutamos nuestro cdigo (F5 es la tecla de ejecucin rpida). De esta
manera nuestro IDLE (Consola da Python) se activara y correr el cdigo. Si todo est correcto, luego de unos
segundos nos tendra que aparecer la siguiente informacin:

Analizando resultados.

Cada nmero en azul representa un valor ledo por el sensor LUX. En este caso muestra un total de 10
valores cada uno separado por un punto en un formato de array unidimensional.
Esto lo podemos verificar analizando el cdigo
Analizando el cdigo.

Analizaremos el cdigo y veremos cmo poder modificarlo para obtener distintos resultados.
1)
import bitalino
device = bitalino.BITalino()

a) Importamos la biblioteca de Bitalino.
b) Almacenamos en la variable device la ruta de nuestro dispositivo.
2)
macAddress = "98:D3:31:B2:14:72"
SamplingRate = 100
device.open(macAddress, SamplingRate)


a) Definimos la MAC del dispositivo al cual nos conectaremos.

b) Definimos los SamplingRate que leer el Bitalino (Mas adelante explicaremos ms detalles al
respecto).
c) Abrimos la conexin al dispositivo con la informacin respectiva.
3)
th = device.battery(20)
BITversion = device.version()
print BITversion

a) Verificamos el estado de la batera del Bitalino.

b) Almacenamos en la variable BITversion la versin del dispositivo.
c) Imprimimos la versin en pantalla (Producto de fallas en el sistema es posible que no se imprima
la versin, de todos modos esto no provocara errores en el cdigo).




4)
device.start([0,1,2,3,4,5])
dataAcquired = device.read(10)
device.trigger([0,0,0,0])
device.stop()
device.close()

a) Activamos la adquisicin de datos en las 6 entradas del dispositivo (Contadas desde la 0 a la 5).
b) Almacenamos en la variable dataAcquired la lectura de datos de las anteriores entradas
activadas. Esto con un valor de lectura de 10 (Se leern 10 datos de cada una de las entradas). En
total la variable dataAcquired contendr una array con ms de 60 datos (10 por cada
entrada). Ms adelante veremos cmo est estructurada esta array.
c) Cerramos los 4 OUTPUT que posee Bitalino. Ms adelante veremos el uso de los OUTPUTs.
d) Detenemos la lectura de datos.
e) Cerramos la conexin BT con el dispositivo.
5)
SeqN = dataAcquired[0,:]
D0 = dataAcquired[1,:]
D1 = dataAcquired[2,:]
D2 = dataAcquired[3,:]
D3 = dataAcquired[4,:]
A0 = dataAcquired[5,:]
A1 = dataAcquired[6,:]
A2 = dataAcquired[7,:]
A3 = dataAcquired[8,:]
A4 = dataAcquired[9,:]
A5 = dataAcquired[10,:]


Esta seccin de cdigo ordena la array bidimensional generada en la lectura de datos. Dispone en
distintas arrays unidimensionales los datos correspondientes a cada entrada.


a) SeqN: Esta array almacenara una secuencia de nmeros de 0 a 15 generada automticamente
por Bitalino.
b) D0,D1,D2,D3: Cada una de estas array almacenara datos nulos, ya que corresponden a las
salidas OUTPUT de Bitalino, las cuales cerramos previamente en el cdigo.
c) A0,A1,A2,A3,A4,A5: Cada una de estas array almacenara los datos correspondiente a cada uno
de los puertos o entradas de Bitalino. En nuestro ejercicio anterior conectamos el sensor LUX al
puerto A0, por lo tanto la array A0 contendr la informacin del respectivo sensor.

Cada una de las 11 arrays(unidimensionales) generadas de la array
dataAcquired(bidimensional) contendr un total de 10 datos.

6)
print A0

Imprimimos en pantalla el contenido de la array A0, la cual posee los datos que necesitamos.





Lectura de datos.

Mediante el cdigo device.start([0,1,2,3,4,5]) podemos definir cuales puertos de entrada
queremos ocupar para leer sus datos. De esta manera device.start([0,1]) solo activara la recepcin de
datos en los puertos A0 y A1 y device.start([4]) solo del puerto A4. Dependiendo de la cantidad de
puertos activados, el nmero de columnas de la array dataAcquired cambiara.
Podemos definir el nmero de datos que queremos procesar mediante el cdigo dataAcquired =
device.read(10) como vimos anteriormente. Si ocupamos un divice.read(100) obtendremos 100 datos de
cada uno de los puertos definidos para leer. O tambin con divice.read(1) solo obtendremos 1 dato por
puerto de entrada. De esto depender el nmero de filas que poseer la array dataAcquired.

El siguiente ejemplo es la estructura de una array dataAcquired generada al leer los datos de los
puertos A0, A1 y A3 sea device.start([0,1,3]) .

La primera columna de la array contendr un valor consecutivo de 0 a 15. Las prximas 4 columnas
contendrn los datos de los OUTPUT sea device.trigger([0,0,0,0]) los cuales correspondern a 0. Estas cuatro
columnas siempre estn presentes en la array, independiente del nmero de puertos configurados para
escuchar o el uso de los OUTPUT. Finalmente las ultimas 3 columnas corresponden a los datos de los puertos
A0, A1 y A3 correspondientemente.

El nmero de filas que tendr esta array es igual al nmero de lecturas que hemos asignado
(divice.read(10)).
Ejemplo: una array dataAcquired de 7 por 90, tendr configurado el almacenamiento de 2 puertos
(ya que la primera columnas ser el Sequence Number y las prximas cuatro los OUTPUT) y 90 lecturas por
cada uno.




Outputs de Bitalino.

Mediante el cdigo device.trigger([0,0,0,0]) podemos activar o desactivar los 4 OUTPUTs
que posee Bitalino. En el ejemplo anterior dejamos todas las salidas desactivadas. Con la activacin de las
salidas podremos encender la unidad LED del Bitalino o tambin ocupar esta seal para conectarla a otros
dispositivos elctricos.

Bitalino trae la posibilidad de activar hasta 2 salidas por defecto. La MCU posee un total de 4, pero
para poder acceder a las restantes 2 es necesario intervenir la placa.

Ejemplo: ocupando device.trigger([1,0,0,0]) activaremos la salida 0 de Bitalino. Si conectamos la
unidad LED a este, el LED se encender. Mediante divice.trigger([0,1,0,0]) activaremos la salida 1 o si
queremos con divice.trigger([1,1,0,0]) activaremos las 2 salidas.








Considerando el lectura, los SamplingsRate y el procesamiento de datos.

Bitalino en estos momentos se encuentra en etapas temprana de desarrollo, por ello es necesario
realizar ciertos ajustes en la comunicacin para poder obtener resultados a tiempo real y sin provocar errores
en el procesamiento de datos.
Primero tenemos que entender cmo funciona el sistema interno de lectura. Mediante el cdigo
SamplingRate = 100 configuramos el Bitalino para que realice 100 lecturas de potenciales elctricos por
segundo de cada puerto. Paralelamente el cdigo device.read(10) lee parte de esta informacin y la
trasforma a datos que puede procesar nuestro computador. En el centro de todo este sistema tambin se
encuentra la unidad BT, la cual trasforma las seales elctricas del MCU al protocolo Bluetooth (seal
inalmbrica).
Es necesario realizar distintas pruebas variando los valores de SamplingRate y divice.read() hasta
encontrar un balance donde veamos que la informacin est fluyendo correctamente entre el Bitalino y el PC.
Entre alguno errores que podemos encontrar est el delay entre la lectura de datos y la muestra de estos en
pantalla; la perdida de velocidad en el programa, provocado por la sobre exigencia del BT; error en el
decoding data provocado por el mal ajuste de estos dos valores; y errores internos de nuestro cdigo
Python al desincronizar las lecturas.
Los ejemplos a continuacin estn probados para una lectura correcta, pero es posible que
dependiendo de las caractersticas del computador estos tengan que ser modificar para obtener resultados
correctos.







Otros cdigos de ejemplo.

Datos a tiempo real 1.

El siguiente cdigo lee a tiempo real el puerto A0. Esto lo hace a una velocidad de 100 SamplingRate, con 10
divice.read() y repite el ciclo de lectura 200 veces. Los datos mencionados pueden tener que ser modificados
dependiendo de la potencia del computar y la calidad del BT. Es posible que salgan errores, se recomienda ajustar los
SamplingRate y divice.read() hasta encontrar la calibracin adecuada del dispositivo.

Link: ( https://github.com/Kromtar/Bitalino/blob/master/BitalinoEjem2 )

Analizando el cdigo podemos ver que las array unidimensionales son desfragmentadas y almacenadas en una
solo variable datos.

Datos a tiempo real 2.

El prximo cdigo lee el modulo LUX, en el puerto A0, ocupando los mismos datos de sincronizacin del ejemplo
anterior. Si el sensor enva un valor bajo 50 enviara el mensaje EncenderLuz a la consola.

Link: ( https://github.com/Kromtar/Bitalino/blob/master/BitalinoEjem3 )

Datos a tiempo real 3.

Este ltimo cdigo es otra variacin del anterior. Si el modulo LUX da un valor bajo 50, se activa el OUTPUT 0
encendiendo el modulo LED. Si el modulo LUX recibe un valor sobre o igual a 50, el modulo LED es apagado. El cdigo
ocupa los mimos datos de sincronizacin que los dos ejemplos anteriores.

Link: ( https://github.com/Kromtar/Bitalino/blob/master/BitalinoEjem4 )

Ahora tu cdigo!

Ya sabiendo cmo trasformar los datos recibidos de Bitalino a arrays unidimensionales, depende de
ti generar algoritmos que puedan trabajar con estas variables y crear programas tiles.