Project : Draagbare monitor en internet-gateway voor (draadloze) biosensoren Inleiding Gebruikte componenten

Transcriptie

1 Project : Draagbare monitor en internet-gateway voor (draadloze) biosensoren Auteur : Henk Stitselaar (henkstitselaar@gmail.com) Datum : 22 december 2015 Inleiding Door middel van dit verslag wil ik toelichten hoe ik tot het behaalde resultaat ben gekomen, en uit welke functionele onderdelen het prototype bestaat. Het boek van Bert van Dam heeft mij op weg geholpen om kennis te maken met de Intel Edison, deze heb ik dan ook volledig doorgewerkt. Hier en daar bleek de praktijk toch anders te zijn, ik heb daarbij niet alle obstakels kunnen oplossen. Door de tegenslagen tijdens de eerste stappen met de ontwikkelomgeving heb ik niet alles wat ik heb voorgesteld ook kunnen realiseren. Uiteindelijk ben ik wel erg tevreden over het resultaat. Er is een werkende demonstratie met de belangrijkste onderdelen, en ik heb kennis kunnen maken met een voor mij nieuwe programmeertaal, python. Gebruikte componenten Zie het schema op de volgende pagina voor de onderdelen van het uiteindelijke prototype. Ik wilde graag de gekregen modules van Seeed toepassen, en uiteindelijk is het volledige prototype opgebouwd uit de onderdelen die geleverd zijn voor mijn deelname. Omdat het prototype naar mijn idee ook over eigen hardware functies moet beschikken, zitten er een blauwe indicatie led, een temperatuur sensor, en ook een microswitch op. Zowel de WiFi als Bluetooth functie worden gebruikt, deze laatste om gegevens van een draadloze biosensor te ontvangen. Voor de demonstratie is er een Bluetooth 4.0 (LE) hartslagmeter uitgekozen, de Polar H7 is geselecteerd omdat deze ook door Intel zelf is gebruikt om de BlueZ bluetooth stack te testen. Via de WiFi verbinding met een draadloze router wordt de gateway functionaliteit van het prototype gedemonstreerd. Voor de eenvoud heb ik de Edison module nu gevoed met een 8V adapter van een oude router.

2 Gebruikte software onderdelen - edison-iotdk-image zip (Yocto 1.7.2) - Putty - WinSCP - Phone Flash Tool Lite - Arduino IDE (uiteindelijk niet gebruikt door compiler fouten) In dit project toegepaste technieken/protocollen - SSH - Telnet - SQLite 3 - Bluetooth LE, BlueZ - Python WiFi Installatie procedure De installatie heb ik uitgevoerd volgens het boek van Bert van Dam, dit moest echter iets anders, het recente image van Intel is te groot ot om op de Edison drive te zetten, dus dat gaat alleen via Flash Tool Lite. De tool geeft echter een timeout, dit is opgelost door de USB kabel er op dat moment kort uit te halen. Putty en WinSCP had ik al op mijn PC staan van eerdere experimenten met de Raspberry pi.

3 Ik heb een WiFi verbinding geprobeerd te maken, maar zonder resultaat. Blijkbaar ontbreekt de default gateway bij de wlan0 interface, hierdoor werkt het internet niet. Deze kan ik wel toevoegen met het volgende commando, dit moet iedere keer bij het opstarten. # ifconfig usb0 down # route add default gw <ip adres van router> Daarnaast heb in mijn router thuis de DHCP lease voor de Edison statisch gemaakt. En ik heb als test een poort van buiten af open gezet, om via SSH op de Edison te werken. Dit gaat goed, ik heb zelfs nog even gewerkt met een SSH client applicatie op mijn telefoon. Programmeeromgeving Ik heb de arduino IDE geïnstalleerd, het was mijn doel om hiermee te gaan programmeren. De nieuwste versie is blijkbaar direct van site van Arduino te downloaden, ik zie in de board manager ook de Edison er bij staan. Ik ben begonnen met de eerste demo sketch, maar ik kon deze niet downloaden naar de Edison, de compiler geeft meteen een foutmelding. Blijkbaar is het path te lang in mijn windows gebruiker directory. Ik heb zelfs nog een oudere versie van Arduino gevonden bij Intel, zonder board manager, maar deze werkt ook niet en geeft dezelfde problemen. Uiteindelijk heb ik toen een andere weg gekozen, de python programmeertaal. Ik heb in python tot nu toe een of twee scripts geschreven, en ben dus echt een beginner. Het nadeel van Arduino is dat het uiteindelijk ook een script in Linux is, dus ik kan die stap ook overslaan. Wiringx86 en Pyserial zijn door mij volgens het boek geïnstalleerd. Hiermee ontstond ook al snel het eerste programma voor het knipperen van de onboard LED op de Edison. Ik heb ook de nano editor geïnstalleerd vanaf sourcecode, deze editor heeft mijn persoonlijke voorkeur. De locatie moet nog wel toevoegen worden aan de PATH variabele, nano staat bij mij in de home directory. # wget # tar xvf nano tar.gz # cd nano #./configure # make # make install DESTDIR=/home/root # export PATH=$PATH:/home/root/usr/local/bin Bluetooth De bluetooth functionaliteit heb ik eerst getest via de tool bluetoothctl, hierbij heb ik gebruik gemaakt van de pdf van Intel: pdf De Polar H7 hartslagsensor staat ook vermeld in dit document, dus ik verwacht hiermee goede resultaten. Door te scannen naar apparaten is het bluetooth mac adres te achterhalen, deze is nodig

4 voor de andere functies. Ik kan direct een connect maken, en ook pairen. Er zijn helaas geen python examples te vinden op de Edison die wel in het pdf document beschreven staan, de source staat echter wel online. Er is echter een problemen in python met bluez-utils, hierdoor werken de examples niet, dit is nergens te vinden. Hierbij heb ik ook de speciale repositories toegevoegd waardoor het een en ander via opkg te installeren is. # nano /etc/opkg/base-feeds.conf En voeg deze regels toe: src/gz all src/gz edison src/gz core # opkg update # opkg install bluez5-dev Dit laatste is niet gelukt, deze package bleek al geïnstalleerd te zijn. Ik heb hierna geprobeerd de eigen GATT server te disabelen, want de Edison werkt alleen als GATT client van de Polar H7 hartslagmeter. Dit kan via # systemctl disable bluetooth, maar bluetoothctl werkt nu ook niet meer. Dit kan dit weer ongedaan maken met # systemctl start bluetooth. De server moet wel disabled worden om straks met gatttool te kunnen werken. Ik heb gatttool geïnstalleerd vanaf sourcecode, deze tool heb ik nodig om straks te verbinden met de Polar H7. De installatie gebeurt door de volledige bluez-5.24 stack opnieuw te compileren en te installeren, inclusief gatttool. # wget # tar -xf bluez-5.24.tar.xz # cd bluez-5.24 #./configure --disable-systemd disable-udev # make # make install # export PATH=$PATH:~/bluez-5.24/attrib/ Het testen met gatttool gaat volgens de pdf van Intel. Nu kan ik uitzoeken welke descriptors we nodig hebben, de hartslag en batterij service zijn standaard. De hartslag is alleen via notify uit te lezen, ik kan dit aan en uit zetten. De hartslag value lijkt met het 2 e byte verzonden te worden. art_rate.xml Ik heb een voorbeeld van Intel gevonden met pexpect, deze module wordt gebruikt om via python de gatttool command line tool te kunnen gebruiken.

5 Installeer hiervoor python-pip, daarna ook setup-tools for pip, en pexpect (niet op website vermeld). # opkg install python-pip # wget # python ez_setup.py # pip install pexpect Dit is gelukt, ik heb enkele aanpassingen gedaan aan de code om ook de notify berichten op te kunnen vangen, deze komen met een interval van ongeveer 1 seconde. De blauwe led knippert bij elke ontvangst van de sensor. De batterijspanning wordt eenmalig bij het opstarten opgevraagd. Hieronder als voorbeeld de output van een test script, met de hexadecimale hartslag waarde: Een startup script aanmaken Wifi werkt bij mij dus niet meteen na opstarten, dit moet worden opgelost door de default gateway toe te voegen. En de bluetooth radio moet ook nog ingeschakeld worden. Als laatste zal het python script gestart moeten worden bij het opstarten van de Edison. Ik heb een voorbeeld gevonden via de volgende link: #!/bin/sh /usr/sbin/rfkill unblock bluetooth /usr/bin/hciconfig hci0 up /usr/bin/python... & Maak het.sh script aan in /etc/init.d (deze map is er nog niet). En maak dit script daarna ook uitvoerbaar ( # chmod +x ), alle aanroepen in het script krijgen een absoluut path. Ik kan hier nog niet de default gateway aanpassen, want ik krijg dan een [FAILED] melding tijdens het opstarten van linux, blijkbaar had het script pas later moeten starten. Hier heb ik een oplossing voor bedacht, start het python script eerst en wacht dan op het indrukken van een knop. Vang daarbij exceptions op, als de Edison er klaar voor is dan zal de functie op de juiste manier worden uitgevoerd. In python is via de system() functie de command line aan te roepen.

6 Data verwerking Voor het loggen van data heb ik eerst de timezone goed gezet. Dit is voor mij Europe/Paris. # timedatectl set-timezone "Europe/Paris" Data wordt geprint naar de command line, maar dat is niet te zien als het script op de achtergrond wordt uitgevoerd. Als eerste stap heb ik een simpele Telnet server opgezet, via de standaard socket module van python en de select module om te zorgen dat de serverfuncties de rest van het programma niet blokkeren (het script moet iedere seconde data ontvangen van de gatttool). De server draait op poort 23, wat standaard is voor Telnet. De client opent de poort en krijgt vanzelf de log data iedere seconde toegestuurd. Ik heb voor dit project geen tijd meer over om de overige functies te realiseren, maar dit voorbeeld bewijst wel dat data gemakkelijk verzonden kan worden naar een externe server. Bijvoorbeeld door een url aan te roepen, en enkele parameters mee te sturen met het http request. De volgende stap is om data te schrijven naar een file op de edison drive, dit is de drive die ook zichtbaar wordt als de Edison met de pc wordt verbonden. Dit kan op de volgende manier: Mount: # rmmod g_multi # mkdir /update # losetup -o 8192 /dev/loop0 /dev/disk/by-partlabel/update # mount /dev/loop0 /update Unmount: # cd / # umount /update # modprobe g_multi

7 Ik heb als voorbeeld een.txt file aangemaakt op de drive, deze is op de pc zichtbaar geworden na het opnieuw verbinden van de Edison. In deze file kunnen log gegevens worden opgeslagen, maar het kan bijvoorbeeld ook een database file zijn (SQLite). Ik heb ook SQLite geïnstalleerd, als de laatste stap voor de opslag van data. Een database is erg gemakkelijk zodra er gegevens gebufferd moeten worden. Er wordt maar met een enkele file gewerkt. Zie ook # wget # tar -xvf sqlite-autoconf tar.gz -z # cd sqlite-autoconf #./configure # make # make install De door mij aangemaakte tabel hiervoor is als volgt opgebouwd: ID Timestamp Heartrate Temperature Battery Bij iedere ontvangst van geldige bluetooth informatie wordt er nu een nieuw record aangemaakt. De hierna volgende afbeeldingen demonstreren dit.

8 De functie van mijn prototype is op dit moment het afgeven van een geluidssignaal ter indicatie van de hartslag. Dit gebeurt met de buzzer module uit de Grove kit. Om de buzzer functie los van de hoofdloop te laten lopen is er met de thread python module een aparte thread aangemaakt. De functie die hierin wordt uitgevoerd kijkt naar een globale variabele voor het simuleren van de gemeten hartslag. De buzzer schakelt met een bepaalde interval kort in. De periode wordt op de volgende manier berekend: T = 60 / aantal slagen per minuut

9 Webinterface In /usr/lib/edison_config_tools/public/status.html staat de Device Information webpagina die tevoorschijn komt als de module via http (poort 80) wordt benaderd, ter demonstratie is de inhoud van het.html bestand gewijzigd. Er was helaas geen tijd om een echte webserver op te zetten, ook het laten functioneren van de Edison in de AP mode heb ik niet gerealiseerd.

10 Python source code #!/usr/bin/python ################################### # File: read_h7_3.py # Project: Edison design contest # Author: H. Stitselaar ################################### ### IMPORT ### import pexpect # gatttool control import sys import time import os from wiringx86 import GPIOEdison as GPIO import socket, select # telnet import thread import sqlite3 import math ### GLOBALS ### gpio = GPIO(debug=False) buzzer_period = 1.0 # seconds = 60/bpm # pin definitions, grove base shield led = 2 button = 5 buzzer = 3 ntc = 14 # pin 14 = analog A0 ### FUNCTIONS ### # Define a function for the buzzer thread def do_buzz(): global buzzer_period global gpio global buzzer # pin D3 try: while True: if (buzzer_period!= 0): # BEEP gpio.digitalwrite(buzzer, gpio.high) time.sleep(0.05) gpio.digitalwrite(buzzer, gpio.low) time.sleep(buzzer_period) else: gpio.digitalwrite(buzzer, gpio.low) except: # Dit voorkomt een gpio exception print "Thread stopped!" # Function to read the grove temperature sensor def read_ntc(): global ntc global gpio B = 4275 #4250 # v1.1 uses thermistor NCP18WF104F03RC, 100k, 1% try: # Take average over 5 samples, at 10 ms interval total_value = 0 for index in range(5):

11 sensor_value = gpio.analogread(ntc) total_value += sensor_value time.sleep(0.01) average_value = float(total_value / 5) R = / average_value R = ( * R) / 2 # HS: delen door 2! t = 1.0 / (math.log(r/ )/b+1/298.15) return t except: raise #return 0 ### MAIN PROGRAM CODE ### # system startup, always enable wifi access first while True: try: time.sleep(5) os.system("ifconfig usb0 down") os.system("route add default gw ") break # continue program except: # keep trying! pass # get argument from the command line # address is 00:22:D0:8C:35:B1 if (len(sys.argv) > 1): bluetooth_adr = sys.argv[1] else: print "No bluetooth address specified!" exit() # raise a SystemExit exception # Init hardware gpio.pinmode(led, gpio.output) # default LOW gpio.pinmode(button, gpio.input) gpio.pinmode(buzzer, gpio.output) # also PWM!, default LOW gpio.pinmode(ntc, gpio.analog_input) # 10-bit ADC, # wait for start button, press when system boot is complete print "Press button to start connection..." init_done = False while (init_done == False): if (gpio.digitalread(button) == True): try: # enable led gpio.digitalwrite(led, gpio.high) # HS: pas het path aan, of maak de aanroep absoluut! tool = pexpect.spawn('/home/root/bluez-5.24/attrib/gatttool -b ' + bluetooth_adr + ' --interactive') tool.expect('\[le\]>') #[LE] print "Preparing to connect. Please enable heartrate sensor." tool.sendline('connect') # wait for successful connection tool.expect('connection successful') tool.expect('\[le\]>') init_done = True gpio.digitalwrite(led, gpio.low) print "Connection successful!"

12 except: gpio.digitalwrite(led, gpio.low) # catch de timeout van pexpect print "Unexpected error! Please try again." try: # Open server socket, telnet port 23 # List to keep track of socket descriptors CONNECTION_LIST = [] # receive data CLIENT_LIST = [] # send data RECV_BUFFER = 2048 server_socket = socket.socket(socket.af_inet, socket.sock_stream) server_socket.setblocking(0) # from another site server_socket.setsockopt(socket.sol_socket, socket.so_reuseaddr, 1) server_socket.bind((" ", 23)) server_socket.listen(5) # Add server socket to the list of readable connections CONNECTION_LIST.append(server_socket) print "Telnet server started on port 23" # database sqlite con = sqlite3.connect('./db/h7data.db') # read battery status, do only once! tool.sendline('char-read-hnd 0x0027') tool.expect('descriptor:.*') # e.g. "Characteristic value/descriptor: 5a" rval = tool.after.split() battery = int(rval[1], 16) # hex to dec print "Battery voltage = {0:d}%".format(battery) # enable h7 heartbeat NOTIFICATION tool.sendline('char-write-req 0x ') tool.expect('characteristic value was written successfully') # Start a thread, no arguments buzzer_period = 0 # buzzer default disabled thread.start_new_thread(do_buzz, ()) print "Starting heartbeat log..." ### MAIN LOOP ### while (True): # notification only! tool.expect('value:.*') # e.g. "Notification handle = 0x0012 value: " rval = tool.after.split() # HS: Timezone is set manually to Europe/Paris localtime = time.asctime(time.localtime(time.time())) # Calculate heartbeat, always the second value bpm = int(rval[2], 16) # hex to dec # Measure temperature sensor temperature = read_ntc() message = "[%s] %d BPM, %.1f degrees Celsius" % (localtime, bpm, temperature) print message

13 # Update the buzzer thread if (bpm > 0): buzzer_period = (60.0 / bpm) else: buzzer_period = 0 # output disabled # Get sockets which are ready to be read, 0.5 seconds timeout read_sockets, write_sockets, error_sockets = select.select(connection_list, CLIENT_LIST, [], 0.5) for sock in read_sockets: # New connection! if (sock == server_socket): # Handle the case in which there is a new connection sockfd, addr = server_socket.accept() sockfd.setblocking(0) CLIENT_LIST.append(sockfd) print "Client (%s, %s) connected" % addr for sock in write_sockets: # Client connected? try: sock.send(message + "\r\n") # Dezelfde data als in de log except: # broken socket connection may be sock.close() CLIENT_LIST.remove(sock) # Add a record to sqlite database with con: cur = con.cursor() # Id is primary key? cur.execute("insert INTO Log VALUES(NULL,?,?,?,?);", (localtime, bpm, temperature, battery)) # Blink led, bluetooth data is received gpio.digitalwrite(led, gpio.high) time.sleep(0.1) gpio.digitalwrite(led, gpio.low) # Program is stopped when user holds the button if gpio.digitalread(button): break # exit while except KeyboardInterrupt: pass # exit program with Ctrl-C ### SHUTDOWN ### print "\nclosing..." # Stop bluetooth notification tool.sendline('char-write-req 0x ') tool.expect('characteristic value was written successfully') tool.expect('\[le\]>') tool.sendline('disconnect') tool.expect('\[le\]>') server_socket.close() gpio.digitalwrite(led, gpio.low) gpio.digitalwrite(buzzer, gpio.low) gpio.cleanup() print "Done"