Nonin-WristOx2-3150-Fluxtream-Gateway.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:20e6587b298b6a0a92105c081b4fd8ed40b9d1288a7401848357dcb01adc9479"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "# Operating and downloading data from the Nonin WristOx2 3150 on a Mac"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from pylab import *\n",
      "%matplotlib inline\n",
      "\n",
      "import datetime, glob, re, serial, struct, subprocess\n",
      "from dateutil import tz\n",
      "from collections import OrderedDict\n",
      "import xml.etree.ElementTree as ET"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 12
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def exec_ipynb(url):\n",
      "    import json, re, urllib2\n",
      "    nb = (urllib2.urlopen(url) if re.match(r'https?:', url) else open(url)).read()\n",
      "    exec '\\n'.join([''.join(cell['input']) for cell in json.loads(nb)['worksheets'][0]['cells'] if cell['cell_type'] == 'code']) in globals()\n",
      "\n",
      "exec_ipynb('Fluxtream-Library.ipynb')\n",
      "fluxtream_login()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "html": [
        "\n",
        "Fluxtream username: <input id=\"fluxtream_username\" type=\"text\"></input><br>\n",
        "Fluxtream password: <input id=\"fluxtream_password\" type=\"password\"></input><br>\n",
        "<button id = \"fluxtream_authenticate\">Authenticate</button> <span id=\"fluxtream_auth_result\"></span>\n",
        "<script>\n",
        "\n",
        "// Send username and password to python\n",
        "function fluxtream_authenticate(username, password, callback) {\n",
        "  cmd =  'fluxtream_authenticate(' + JSON.stringify(username) + ',' +\n",
        "         JSON.stringify(password) + ')'\n",
        "  console.log(cmd);\n",
        "  function cb(msg) {\n",
        "    console.log(msg);\n",
        "    console.log(msg.content.data['text/plain'] == 'True');\n",
        "    callback(msg.content.data['text/plain'] == 'True')\n",
        "  }\n",
        "  IPython.notebook.kernel.execute(cmd, \n",
        "                                  {iopub: {output: cb}}, {silent: false});\n",
        "}\n",
        "\n",
        "$('#fluxtream_authenticate').click(function() {\n",
        "    $('#fluxtream_auth_result').text('...');\n",
        "    fluxtream_authenticate($('#fluxtream_username').val(),\n",
        "                           $('#fluxtream_password').val(),\n",
        "                           function(success) {\n",
        "                             $('#fluxtream_auth_result').text(success ? 'Success' : 'Failed');\n",
        "                           });\n",
        "});\n",
        "</script>\n"
       ],
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 13,
       "text": [
        "<IPython.core.display.HTML at 0x10820d410>"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Note:  if you are missing the \"serial\" package, you'll want to install pySerial\n",
      "# On a mac, we've had luck installing by typing\n",
      "# easy_install pySerial\n",
      "# from the commandline\n",
      "\n",
      "\n",
      "# Interface to Nonin 3150\n",
      "#\n",
      "# Using references from Nonin:\n",
      "#    \"3150-Specifications_7970_000-Rev-A.pdf\"\n",
      "#    \"3150 Commands.docx\" (includes format of memory playback)\n",
      "\n",
      "class Nonin3150:\n",
      "    \"\"\"Interface to Nonin WristOx2 3150\"\"\"\n",
      "    \n",
      "    fields = OrderedDict([\n",
      "        ('Reserved1',                    'c'), # Length 1.  \n",
      "        ('BluetoothEnable',              'c'), # ASCII len 1. enabled:'1', disabled:'2'\n",
      "        ('ActivationOption',             'c'), # ASCII len 1.  always log:'1', use start/stop time:'2', display only:'3'\n",
      "        ('StorageRate',                  'c'), # ASCII len 1.  every second:'1', 2 seconds: '2', 4 seconds: '4'\n",
      "        ('DisplayOption',                'c'), # ASCII len 1.  full display while logging:'1', partial display:'2'\n",
      "        ('StartTime1',                 '10s'), # ASCII YYMMDDhhmm.  Only used for ActivationOption '2'\n",
      "        ('StopTime1',                  '10s'), # ASCII YYMMDDhhmm.  Only used for ActivationOption '2'\n",
      "        ('StartTime2',                 '10s'), # ASCII YYMMDDhhmm.  Only used for ActivationOption '2'\n",
      "        ('StopTime2',                  '10s'), # ASCII YYMMDDhhmm.  Only used for ActivationOption '2'\n",
      "        ('StartTime3',                 '10s'), # ASCII YYMMDDhhmm.  Only used for ActivationOption '2'\n",
      "        ('StopTime3',                  '10s'), # ASCII YYMMDDhhmm.  Only used for ActivationOption '2'\n",
      "        ('ProgrammableIdentification', '50s'), # ASCII len 50.  Arbitrary ID settable by user\n",
      "        ('SoftwarePartNumber',          '4s'), # ASCII len 50.  First 4 digits\n",
      "        ('SoftwareRevision',            '3s'), # ASCII len 3\n",
      "        ('SoftwareRevDate',             '6s'), # ASCII YYMMDD\n",
      "        ('Reserved2',                   '6s'), # Length 6\n",
      "    ])\n",
      "\n",
      "    format = ''.join(fields.values())\n",
      "    \n",
      "    date_format = '%Y-%m-%d %H:%M:%S %Z'\n",
      "    \n",
      "    def __init__(self):\n",
      "        self.device_path = self.find_device_path()\n",
      "        print 'Opening %s...' % self.device_path\n",
      "        self.device = serial.Serial(self.device_path, timeout=1)\n",
      "        print 'Opened %s' % self.device_path\n",
      "        config = self.get_config()\n",
      "        print ('Found Nonin 3150 at %s, software %s.%s.20%s' % \n",
      "               (self.device_path, config['SoftwarePartNumber'], \n",
      "                config['SoftwareRevision'], config['SoftwareRevDate']))\n",
      "        time = self.get_current_time()\n",
      "        print 'Current time as reported by device in GMT: %s' % time.strftime(self.date_format)\n",
      "        localtime = time.astimezone(tz.tzlocal())\n",
      "        print '  (Converted to your current local timezone: %s)' % localtime.strftime(self.date_format)\n",
      "\n",
      "    @staticmethod\n",
      "    def find_device_path():\n",
      "        try:\n",
      "            ioreg = subprocess.check_output(['ioreg', '-l', '-w', '0', '-c', 'IOUSBDevice', '-r'])\n",
      "            candidates = [match.group(1) for match in re.finditer(r'\"USB Product Name\" = \"Model 3150\".*\"USB Vendor Name\" = \"Nonin.*\"IOCalloutDevice\" = \"(.*?)\"', ioreg, re.DOTALL)]\n",
      "        except:\n",
      "            candidates = glob.glob('/dev/cu.usbmodem*')\n",
      "        if len(candidates) == 0:\n",
      "            raise Exception(\"Can't find Nonin device.  Please be sure it's plugged in using the USB cable.\")\n",
      "        if len(candidates) > 1:\n",
      "            raise Exception(\"Hmm, found multiple USB serial ports.  Need to address this issue in the software.\")\n",
      "        return candidates[0]\n",
      "    \n",
      "    def get_config(self):\n",
      "        self.device.flushInput()\n",
      "        self.device.write('CFG?\\r\\n')\n",
      "        self.require_ack()\n",
      "        data = self.require_bytes(134)\n",
      "        checksum = struct.unpack('>H', self.require_bytes(2))[0]\n",
      "        if checksum != sum([ord(ch) for ch in data]):\n",
      "            raise Exception('CFG? incorrect checksum')\n",
      "        unpacked = struct.unpack(self.format, data)\n",
      "        return OrderedDict(zip(self.fields.keys(), unpacked))\n",
      "    \n",
      "    def set_config(self, config):\n",
      "        if config.keys() != self.fields.keys():\n",
      "            raise Exception('config must be an OrderedDict with keys as returned from get_config')\n",
      "        data = struct.pack(self.format, *config.values())\n",
      "        checksum = struct.pack('>H', sum([ord(ch) for ch in data]))\n",
      "        self.device.flushInput()\n",
      "        self.device.write('CFG=' + data + checksum + '\\r\\n')\n",
      "        self.require_ack()\n",
      "        self.require_crlf()\n",
      "        \n",
      "    def enable_logging(self, interval=1):\n",
      "        config = self.get_config()\n",
      "        \n",
      "        # Always log when sensor detects signal\n",
      "        config['ActivationOption'] = '1'\n",
      "        \n",
      "        interval = int(interval)\n",
      "        valid_intervals = [1,2,4]\n",
      "        if not interval in valid_intervals:\n",
      "            raise Exception('interval must be one of %s' % valid_intervals)\n",
      "        config['StorageRate'] = str(interval)\n",
      "        \n",
      "        self.set_config(config)\n",
      "    \n",
      "    # By convention, this library always stores time on the 3150 in UTC, since the 3150\n",
      "    # supports neither daylight savings time nor timezones.\n",
      "    \n",
      "    def get_current_time(self):\n",
      "        self.device.flushInput()\n",
      "        self.device.write('DTM?\\r\\n')\n",
      "        self.require_ack();\n",
      "        time = self.require_bytes(12)\n",
      "        self.require_crlf();\n",
      "        return datetime.datetime.strptime(time, '%y%m%d%H%M%S').replace(tzinfo=tz.tzutc())\n",
      "    \n",
      "    def set_current_time(self):\n",
      "        self.device.flushInput()\n",
      "        # Write time in UTC, format YYMMDDhhmmss\n",
      "        self.device.write(datetime.datetime.utcnow().strftime('DTM=%y%m%d%H%M%S\\r\\n'))\n",
      "        self.require_ack()\n",
      "        self.require_crlf()\n",
      "    \n",
      "    def get_header(self):\n",
      "        self.device.flushInput()\n",
      "        self.device.write('HDR?\\r\\n')\n",
      "        self.require_ack()\n",
      "        return self.read_until_timeout()\n",
      "    \n",
      "    def clear_sessions(self):\n",
      "        self.device.flushInput()\n",
      "        self.device.write(datetime.datetime.utcnow().strftime('MCL!\\r\\n'))\n",
      "        self.require_ack()\n",
      "        self.require_crlf()\n",
      "        print \"Sessions cleared on Nonin\"\n",
      "        \n",
      "    def read_sessions(self):\n",
      "        self.device.flushInput()\n",
      "        self.device.write('MPB?\\r\\n')\n",
      "        self.require_ack()\n",
      "        print 'Reading memory from Nonin...'\n",
      "        memory = self.read_until_timeout()\n",
      "        print 'Read %d bytes' % len(memory)\n",
      "        if len(memory) % 3 != 0:\n",
      "            raise Exception('MPB?: Invalid memory length read')\n",
      "    \n",
      "        # Check and strip checksums\n",
      "        data = []\n",
      "        for i in range(0, len(memory) / 3):\n",
      "            bytes = [ord(ch) for ch in memory[i * 3 : (i + 1) * 3]]\n",
      "            if (bytes[0] + bytes[1]) % 256 != bytes[2]:\n",
      "                raise Exception('MPB?: invalid checksum in triplet %d' % i)\n",
      "            data.append((bytes[0], bytes[1]))\n",
      "\n",
      "        # Decode sessions\n",
      "        header = (254, 253)\n",
      "        i = 0\n",
      "        sessions = []\n",
      "        while i < len(data):\n",
      "            if data[i] != header:\n",
      "                raise Exception('MPB?: invalid header at triplet %d' % i)\n",
      "            print 'Session header starting at triplet %d' % i\n",
      "            i += 1\n",
      "    \n",
      "            (seconds_per_sample, format) = data[i]\n",
      "            if format != 2:\n",
      "                raise Exception('MPB?: unknown format at triplet %d' % i)\n",
      "            i += 1\n",
      "            print '  Seconds per sample: %d' % seconds_per_sample\n",
      "    \n",
      "            current_time = self.decode_memory_time(data, i); i += 3\n",
      "        \n",
      "            # Don't read start and stop time unless we confirm there are samples\n",
      "            # The Nonin tends to have an empty session, with invalid start and stop time\n",
      "            stop_time_index = i; i += 3;\n",
      "            start_time_index = i; i += 3;\n",
      "    \n",
      "            session = []\n",
      "            valid = False\n",
      "            while i < len(data) and data[i] != header:\n",
      "                if len(session) == 0:\n",
      "                    # We have a non-empty session.  Go ahead and parse the times\n",
      "                    # Samples are reversed in time\n",
      "                    sample_time = stop_time = self.decode_memory_time(data, stop_time_index);\n",
      "                    start_time = self.decode_memory_time(data, start_time_index);\n",
      "    \n",
      "                    if start_time and stop_time:\n",
      "                        print '  Time range: %s to %s' % (start_time.strftime(self.date_format),\n",
      "                                                          stop_time.strftime(self.date_format))\n",
      "                        valid = True\n",
      "                    else:\n",
      "                        print '  Invalid start or stop time'\n",
      "\n",
      "                (pulse_rate, spo2) = data[i]; i += 1\n",
      "                if pulse_rate == 255:\n",
      "                    pulse_rate = None\n",
      "                elif pulse_rate > 200:\n",
      "                    # Values over 200 are compressed to handle high pulse rates\n",
      "                    pulse_rate = 200 + (pulse_rate - 200) * 2\n",
      "                if spo2 == 255:\n",
      "                    spo2 = None\n",
      "                session.append((sample_time, pulse_rate, spo2))\n",
      "                if sample_time:\n",
      "                    sample_time -= datetime.timedelta(seconds=1)\n",
      "            session.reverse()\n",
      "                    \n",
      "            print '  %s data samples' % len(session)\n",
      "            if valid and len(session) > 0:\n",
      "                sessions.append(session)\n",
      "        \n",
      "        print 'Total of %d valid sessions' % len(sessions)\n",
      "        return sessions\n",
      "\n",
      "    @staticmethod\n",
      "    def decode_memory_time(memory, i):\n",
      "        [(month, day), (year, minute), (second, hour)] = memory[i : i + 3]\n",
      "        try:\n",
      "            return datetime.datetime(year + 2000, month, day, hour, minute, second, tzinfo=tz.tzutc())\n",
      "        except:\n",
      "            print \"Couldn't make a time from YY=%d MM=%d DD=%d HH:MM:SS=%d:%d:%d\" % (year, month, day, hour, minute, second)\n",
      "            return None\n",
      "\n",
      "    def read_until_timeout(self):\n",
      "        ret = ''\n",
      "        while True:\n",
      "            read = self.device.read(1000)\n",
      "            if read == '':\n",
      "                return ret\n",
      "            ret += read\n",
      "            \n",
      "    def require_bytes(self, n):\n",
      "        ret = ''\n",
      "        while len(ret) < n:\n",
      "            read = self.device.read(n - len(ret))\n",
      "            ret += read\n",
      "            if read == '':\n",
      "                raise Exception('Expected %d bytes but only received %d' % (n, len(ret)))\n",
      "        return ret\n",
      "    \n",
      "    def require_ack(self):\n",
      "        if self.device.read(1) != '\\x06':\n",
      "            raise Exception('Expected ACK not received')\n",
      "    \n",
      "    def require_crlf(self):\n",
      "        if self.device.read(2) != '\\r\\n':\n",
      "            raise Exception('Expected CRLF not received')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "nonin = Nonin3150()\n",
      "\n",
      "nonin.enable_logging()\n",
      "\n",
      "# Set time on Nonin from laptop, using GMT timezone\n",
      "current_time = nonin.get_current_time()\n",
      "print 'Before setting Nonin clock:'\n",
      "print current_time.strftime('   Time on Nonin, GMT: %Y-%m-%d %H:%M:%S UDT')\n",
      "print current_time.astimezone(tz.tzlocal()).strftime('   Time on Nonin, translated to local timezone: %Y-%m-%d %H:%M:%S%z')\n",
      "print 'Setting clock on Nonin to current host time...'\n",
      "nonin.set_current_time()\n",
      "current_time = nonin.get_current_time()\n",
      "print 'After setting Nonin clock:'\n",
      "print current_time.strftime('   Time on Nonin, GMT: %Y-%m-%d %H:%M:%S UDT')\n",
      "print current_time.astimezone(tz.tzlocal()).strftime('   Time on Nonin, translated to local timezone: %Y-%m-%d %H:%M:%S%z')\n",
      "\n",
      "sessions = nonin.read_sessions()\n",
      "\n",
      "import itertools\n",
      "samples = list(itertools.chain(*sessions))\n",
      "print len(samples), 'samples'\n",
      "\n",
      "fig, ax = plt.subplots(figsize=(40,6))\n",
      "\n",
      "times = [sample[0] for sample in samples]\n",
      "\n",
      "ax.plot(times, [sample[1] for sample in samples], label=\"Pulse\")\n",
      "ax.plot(times, [sample[2] for sample in samples], label=\"SpO2\")\n",
      "\n",
      "# Legend above plot\n",
      "ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.10),\n",
      "          fancybox=True, shadow=True, ncol=5)\n",
      "\n",
      "# plt.gcf().autofmt_xdate()  # Nice dates on X axis\n",
      "\n",
      "#ax.xaxis.set_major_formatter(FuncFormatter(lambda x, pos: '%.6f' % x))\n",
      "\n",
      "ax.grid(alpha=0.5, linestyle='dashed', linewidth=0.5) # Grid\n",
      "\n",
      "ax.xaxis.set_major_formatter(matplotlib.dates.DateFormatter('%m/%d %H:%M:%S %Z', tz=tz.tzlocal()))\n",
      "plt.xticks(rotation='vertical')\n",
      "\n",
      "None"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Opening /dev/cu.usbmodemfd13421...\n",
        "Opened /dev/cu.usbmodemfd13421\n",
        "Found Nonin 3150 at /dev/cu.usbmodemfd13421, software 7813.026.20130702\n",
        "Current time as reported by device in GMT: 2014-09-30 23:58:31 UTC\n",
        "  (Converted to your current local timezone: 2014-09-30 19:58:31 EDT)\n",
        "Before setting Nonin clock:"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "   Time on Nonin, GMT: 2014-09-30 23:58:31 UDT\n",
        "   Time on Nonin, translated to local timezone: 2014-09-30 19:58:31-0400\n",
        "Setting clock on Nonin to current host time...\n",
        "After setting Nonin clock:\n",
        "   Time on Nonin, GMT: 2014-09-30 23:58:32 UDT\n",
        "   Time on Nonin, translated to local timezone: 2014-09-30 19:58:32-0400\n",
        "Reading memory from Nonin...\n",
        "Read 33 bytes"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "Session header starting at triplet 0\n",
        "  Seconds per sample: 1\n",
        "  0 data samples\n",
        "Total of 0 valid sessions\n",
        "0 samples\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stderr",
       "text": [
        "/Users/rsargent/anaconda/lib/python2.7/site-packages/IPython/core/formatters.py:239: FormatterWarning: Exception in image/png formatter: ordinal must be >= 1\n",
        "  FormatterWarning,\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "display_data",
       "text": [
        "<matplotlib.figure.Figure at 0x108226b90>"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "import base64\n",
      "import json\n",
      "import httplib\n",
      "import urllib\n",
      "\n",
      "# Concatenate all the sessions into a single list of samples\n",
      "samples = list(itertools.chain(*sessions))\n",
      "\n",
      "# April 2014:  Bug in fluxtream.org prevents uploading samples with nulls;  for now, filter out None's\n",
      "# We can remove these 3 lines once that's fixed\n",
      "print '%d samples' % len(samples)\n",
      "samples = [sample for sample in samples if not None in sample]\n",
      "print '%d samples after filtering out samples containing None' % len(samples)\n",
      "\n",
      "def epoch_time(dt):\n",
      "    epoch = datetime.datetime(1970, 1, 1, tzinfo=tz.tzutc())\n",
      "    return (dt - epoch).total_seconds()    \n",
      "\n",
      "# Convert timestamps to epoch time\n",
      "\n",
      "print 'Data has %d samples' % len(samples)\n",
      "data = [[epoch_time(sample[0]), sample[1], sample[2]] for sample in samples]\n",
      "print 'Excerpt:', data[0:10]\n",
      "\n",
      "dev_nickname = 'Nonin3150'\n",
      "channel_names = ['Pulse', 'SpO2']\n",
      "\n",
      "success = fluxtream_upload(dev_nickname, channel_names, data)\n",
      "\n",
      "if success:\n",
      "    nonin.clear_sessions()\n",
      "    \n",
      "print datetime.datetime.now().strftime('Current timestamp: %Y-%m-%d %H:%M:%S')"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "26120 samples\n",
        "26071 samples after filtering out samples containing None\n",
        "Data has 26071 samples\n",
        "Excerpt:"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        " [[1412041235.0, 100, 93], [1412041236.0, 100, 93], [1412041237.0, 103, 93], [1412041238.0, 98, 93], [1412041239.0, 98, 93], [1412041240.0, 98, 93], [1412041241.0, 98, 93], [1412041242.0, 98, 93], [1412041256.0, 92, 93], [1412041257.0, 132, 93]]\n",
        "Uploading 26071 data points to rsargent's account on server fluxtream.org, device Nonin3150, channels ['Pulse', 'SpO2']\n",
        "Current timestamp: 2014-09-30 19:58:01"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n"
       ]
      }
     ],
     "prompt_number": 11
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}