Integral Design

Sending data to a Web service from a device with an embedded microprocessor is a very common and useful scenario.  This example demonstrates the procedures using the .NET Gadgeteer Pulse Oximeter manufactured by Seeed Studio and a REST Web service implemented on the Windows Communication Foundation (WCF) platform.

This post has been updated to use HttpHelper.CreateHttpPostRequest.

The Seeed Pulse Oximeter is a monitoring device that measures pulse and non-invasively detects oxygen saturation of the blood.  An earlier post shows how to use the the Pulse Oximeter in a .NET Gadgeteer application.  This example adds display of data using the Display_T35 module manufactured by GHI Electronics. This post also demonstrates the implementation of a REST Web service that records data about pulse and blood oxygenation from the Pulse Oximeter. The monitoring device can be near or far from the Web service that records data and provides display of the data in a Web browser.

The Web service implementation uses the Windows Communication Foundation (WCF) REST service template for C# and version 4.0 of the .NET Framework.  Data is recorded using programmable classes based on the .NET Entity Framework.  The Entity Framework (EF) is an object-relational mapping model supported by the .NET platform.  Visual Studio provides templates for using the Entity Framework and Entity Data Model (EDM) . The EDM maps programmable classes to a relational database, in this case the data is stored in SQL Server Express. Entity objects manage data in the methods stubbed out by the WCF template.

The display page for data recorded by the service is a simple ASP.NET Web form with a GridView control and the Entity Data Source control.  If you are interested in extensive use of the EDM and/or the Entity Data Source control, see The Entity Framework and ASP.NET for an introduction and tutorial.

This example also uses the .NET Micro Framework Interim Solution to Ethernet_J11D workaround for the Ethernet module limitations.  As soon as this is fixed, some of the Web request syntax will be replaced with objects based on the the .NET Gadgeteer.Networking Namespace.

Pulse Oximeter Probe Attached

Monitoring Pulse and Blood Oxygenation Data with the Seeed Pulse Oximeter

The following code block shows the initialization of the PulseOximeter ProbeAttached, ProbeDetached, and Heartbeat events and a timer to regulate pulse and blood oxygenation data posts at 10 second intervals to the Web service.  The ButtonPressed event handler starts the timer and initializes the PulseOximeter.HeartbeatHandler.  On each pulseOximeter_Heartbeat event, the pulse and blood oxygenation data are displayed on the screen of the GHI Electronics Display_T35 module. The EthernetConnection object, which is used to send data to the Web service, is an instance of the workaround class, which is shown after the code for the PulseOximeter sensor.

using System;
using Microsoft.SPOT;
using System.Net;
using GT = Gadgeteer;
using Gadgeteer.Modules.GHIElectronics;
using Gadgeteer.Modules.Seeed;

// These directives support the EthernetConnection class workaround: http://wp.me/p1TEdE-bj .
using Microsoft.SPOT.Net.NetworkInformation; // Add this using directive.
using GHINET = GHIElectronics.NETMF.Net; // Add a reference to this libaray and using directive.

namespace PulseOxToWebService
{
    public partial class Program
    {
        string name;
        string pulseRate;
        string oxSat;
        GT.Timer timer;

        uint xIndex = 5;

        EthernetConnection ethernet;
        static bool IsNetworkUp = false;
        static public bool ethernet_last_status = false;

        void ProgramStarted()
        {
            pulseOximeter.ProbeAttached +=
            new PulseOximeter.ProbeAttachedHandler(pulseOximeter_ProbeAttached);
            pulseOximeter.ProbeDetached +=
            new PulseOximeter.ProbeDetachedHandler(pulseOximeter_ProbeDetached);
            button.ButtonPressed +=
                new Button.ButtonEventHandler(button_ButtonPressed);

            timer = new GT.Timer(10000);
            timer.Tick += new GT.Timer.TickEventHandler(timer_Tick);

            ethernet = new EthernetConnection();

            name = "TestName-4";
            Debug.Print("Using name: " + name);
            Debug.Print("Program Started");

            display.SimpleGraphics.DisplayText("Name: " + name,
                Resources.GetFont(Resources.FontResources.NinaB), GT.Color.Red, 50, 60);
                display.SimpleGraphics.DisplayText("Network up? " + IsNetworkUp,
                Resources.GetFont(Resources.FontResources.NinaB), GT.Color.Red, 50, 75);
        }

        void button_ButtonPressed(Button sender, Button.ButtonState state)
        {
            if (!button.IsLedOn && pulseOximeter.IsProbeAttached)
            {
                pulseOximeter.Heartbeat +=
                    new PulseOximeter.HeartbeatHandler(pulseOximeter_Heartbeat);
                button.TurnLEDOn();
                timer.Start();
            }
            else
            {
                pulseOximeter.Heartbeat -=
                    new PulseOximeter.HeartbeatHandler(pulseOximeter_Heartbeat);
                button.TurnLEDOff();
                timer.Stop();
            }
        }

        void timer_Tick(GT.Timer timer)
        {
            if (IsNetworkUp)
            {
                ethernet.SendPulseOximeterData(name, pulseRate, oxSat);
            }
            else
            {
                    display.SimpleGraphics.DisplayRectangle(GT.Color.Black, 2, GT.Color.Black, 50, 75, 150, 25);
                    display.SimpleGraphics.DisplayText("Network up? " + IsNetworkUp,
                    Resources.GetFont(Resources.FontResources.NinaB), GT.Color.Red, 50, 75);

                pulseOximeter.Heartbeat -=
                        new PulseOximeter.HeartbeatHandler(pulseOximeter_Heartbeat);
                button.TurnLEDOff();
                timer.Stop();
            }
        }

        void pulseOximeter_Heartbeat(PulseOximeter sender, PulseOximeter.Reading reading)
        {
            pulseRate = reading.PulseRate.ToString();
            oxSat = reading.SPO2.ToString();

            display.SimpleGraphics.DisplayRectangle(GT.Color.Blue, 2, GT.Color.Black, 5, 5, 150, 25);
            display.SimpleGraphics.DisplayRectangle(GT.Color.Blue, 2, GT.Color.Black, 5, 30, 150, 25);

            display.SimpleGraphics.DisplayTextInRectangle("Oxygen Saturation: " + oxSat, 10, 10, 150, 50,
                                 GT.Color.Orange, Resources.GetFont(Resources.FontResources.small));
            display.SimpleGraphics.DisplayTextInRectangle("Pulse: " + pulseRate, 10, 35, 150, 50,
                                 GT.Color.Green, Resources.GetFont(Resources.FontResources.small));

            uint graph_x = xIndex++;

            if (graph_x + 5 > display.Width)
            {
                xIndex = 5;
                display.SimpleGraphics.Clear();
            }

            uint graph_y = (uint)reading.PulseRate;     // Scale the voltage to size of display.
            display.SimpleGraphics.SetPixel(GT.Color.Green, graph_x, display.SimpleGraphics.Height - graph_y);
            graph_y = (uint)reading.SPO2;
            display.SimpleGraphics.SetPixel(GT.Color.Orange, graph_x, display.SimpleGraphics.Height - graph_y);
        }

        void pulseOximeter_ProbeAttached(PulseOximeter sender)
        {
            display.SimpleGraphics.DisplayRectangle(GT.Color.Black, 2, GT.Color.Black, 25, 75, 150, 25);
            display.SimpleGraphics.DisplayText("Probe attached.",
                Resources.GetFont(Resources.FontResources.NinaB), GT.Color.Green, 25, 75);

            display.SimpleGraphics.DisplayRectangle(GT.Color.Black, 2, GT.Color.Black, 25, 90, 150, 25);
            display.SimpleGraphics.DisplayText("Network up? " + IsNetworkUp,
                Resources.GetFont(Resources.FontResources.NinaB), IsNetworkUp? GT.Color.Green: GT.Color.Red, 25, 90);
        }

        void pulseOximeter_ProbeDetached(PulseOximeter sender)
        {
            display.SimpleGraphics.DisplayRectangle(GT.Color.Black, 2, GT.Color.Black, 25, 75, 150, 25);
            display.SimpleGraphics.DisplayText("Probe detached.",
                Resources.GetFont(Resources.FontResources.NinaB), GT.Color.Red, 25, 75);

            display.SimpleGraphics.DisplayRectangle(GT.Color.Black, 2, GT.Color.Black, 25, 90, 150, 25);
                     display.SimpleGraphics.DisplayText("Network up? " + IsNetworkUp,
                     Resources.GetFont(Resources.FontResources.NinaB), IsNetworkUp ? GT.Color.Green : GT.Color.Red, 25, 90);

            timer.Stop();
            button.TurnLEDOff();
            pulseOximeter.Heartbeat -=
                    new PulseOximeter.HeartbeatHandler(pulseOximeter_Heartbeat);
        }
    }
}

Pulse Oximeter Data Display

Ethernet Connection Class

The EthernetConnection class contains the initialization of a network connection and a method to send PulseOximeter data to the Web service.  While debugging, the code prints IP and DNS information to the output window of Visual Studio.

The SendPulseOximeterData method initializes and sends an HttpWebRequest POST that contains the name of the subject whose vital signs are being monitored and the pulse and blood oxygenation data.  You can use the static CreateHttpPostRequest method of HttpHelper to create the request to the Web service.  The account identifier is specified by the URL  (the URL template is described in the Web service implementation following this code).  This example doesn’t need any information in the body of the POST request, so the POSTContent parameter is created without content.  Content type is null. This is an asynchronous method that gets the response in the delegate method, HttpRequest.ResponseReceived. The delegate is assigned before calling HttpRequest.SendRequest.

    class EthernetConnection
    {
        NetworkInterface[] netif = NetworkInterface.GetAllNetworkInterfaces();
        static public bool network_is_read = false;

        public EthernetConnection()
        {
            if (!GHINET.Ethernet.IsEnabled)
            {
                GHINET.Ethernet.Enable();
            }

            if (!GHINET.Ethernet.IsCableConnected)
            {
                Debug.Print("Cable is not connected!");
                IsNetworkUp = false;
            }

            Debug.Print("Ethernet cable is connected!");
            Debug.Print("Enable DHCP");
            try
            {
                if (!netif[0].IsDhcpEnabled)
                netif[0].EnableDhcp();  // This function is blocking
                else
                {
                    netif[0].RenewDhcpLease();  // This function is blocking
                }
                network_is_read = true;
                Debug.Print("Network settings:");
                Debug.Print("IP Address: " + netif[0].IPAddress);
                Debug.Print("Subnet Mask: " + netif[0].SubnetMask);
                Debug.Print("Default Getway: " + netif[0].GatewayAddress);
                Debug.Print("DNS Server: " + netif[0].DnsAddresses[0]);

                IsNetworkUp = true;
            }
            catch
            {
                IsNetworkUp = false;
                Debug.Print("DHCP Faild");
            }
        }

        public void SendPulseOximeterData(string name, string pulse, string oxg)
        {
            led.BlinkRepeatedly(GT.Color.White);

            POSTContent emptyPost = new POSTContent();
            var req =
                HttpHelper.CreateHttpPostRequest("http://integral-data.com/PulseOxData/reading/" +
                           name + "/" + pulse + "/" + oxg, emptyPost, null);

            req.ResponseReceived += new HttpRequest.ResponseHandler(req_ResponseReceived);
            req.SendRequest();
        }

        void req_ResponseReceived(HttpRequest sender, HttpResponse response)
        {
            if (response.StatusCode != "200")
            {
                Debug.Print(response.StatusCode);
                IsNetworkUp = false;
            }

            led.TurnOff();
        }
    }

Web Service to Record Pulse Oximeter Data and ASP.NET WebForm to Display the Data

Implementation of a Web service based on the Visual Studio WCF REST Web Service template has been detailed in a previous post: REST Web Service to Record Data from a .NET Gadgeteer Sensor Device.  As in the previous example, this Web service implements a POST method to record data. The URL syntax of the POST method contains the name of the subject and pulse and blood oxygenation data obtained from the PulseOximeter sensor.  The Web service also implements a GET method that can be used to get the data for a particular subject in XML format.  It also implements a ASP.NET Web Form to display the data in a datagrid control.

The data is contained by a database in SQL Server Express and mapped to Entity Data Model objects.  The Visual Studio tools and templates make this process quite simple.  See the post REST Web Service to Record Data from a .NET Gadgeteer Sensor Device for details of using the template, and see The Entity Framework and ASP.NET for more on the Entity Data Model (EDM) and ASP.NET.

The following illustration show the Entity Data Model for the Pulse Oximeter data in Visual Studio after a wizard creates it.

Entity Data Model in WCF REST Template

The following code contains the implentation of the GET and  POST methods for the REST PulseOxDataService.  The POST method URL syntax includes the path: “reading” and three parameters that follow forward slash (/) characters: {name}, {pulse}, and {ox}.  The path element, “reading”, is used literally in the URL string, and the parameters inside brackets {} are replaced by the actual values of subject name, pulse, and blood oxygenation.   All the parameters are sent as strings in accord with the text-based format of Internet protocol and REST.

The path element, “data”, indicates the GET method, and is followed by (/) and {name}, to spevcify the name of the subject of the tests for which to query.

    public class PulseOxDataService
    {
        // TODO: Implement the collection resource that will contain the SampleItem instances.
        // We don't need this collection because we're using Entity Data Model
        // mapped to SQL Server Compact Edition.

        [WebInvoke(UriTemplate = "reading/{name}/{pulse}/{ox}", Method = "POST")]
        public PulseOxReading Create(string name, string pulse, string ox)
        {
            using (PulseOxDatabaseEntities objectContext = new PulseOxDatabaseEntities())
            {
                PulseOxReading newReading = new PulseOxReading();
                newReading.Name = name;
                newReading.Pulse = int.Parse(pulse);
                newReading.OxygenSaturation = int.Parse(ox);
                newReading.Time = DateTime.Now;

                objectContext.PulseOxReadings.AddObject(newReading);
                objectContext.SaveChanges();

                return newReading;
            }
        }

        [WebGet(UriTemplate = "data/{name}")]
        public List GetCollection(string name)
        {
            using(PulseOxDatabaseEntities objectContext = new PulseOxDatabaseEntities())
            {
                List<PulseOxReading> list =
                    objectContext.PulseOxReadings.Where(item => item.Name == name).ToList<PulseOxReading>();
                return list;
            }
        }
    }

The GET method returns entity data serialized as XML as shown in the following example.

<ArrayOfPulseOxReading xmlns="http://schemas.datacontract.org/2004/07/PulseOxData"
                       xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
  <PulseOxReading z:Id="i1" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
    <EntityKey z:Id="i2" xmlns="http://schemas.datacontract.org/2004/07/System.Data.Objects.DataClasses"
               xmlns:a="http://schemas.datacontract.org/2004/07/System.Data">
      <a:EntityContainerName>PulseOxDatabaseEntities</a:EntityContainerName>
      <a:EntityKeyValues>
        <a:EntityKeyMember>
          <a:Key>Id</a:Key>
          <a:Value i:type="b:int" xmlns:b="http://www.w3.org/2001/XMLSchema">5</a:Value>
        </a:EntityKeyMember>
      </a:EntityKeyValues>
      <a:EntitySetName>PulseOxReadings</a:EntitySetName>
    </EntityKey>
    <Id>5</Id>
    <Name>TestName-4</Name>
    <OxygenSaturation>73</OxygenSaturation>
    <Pulse>63</Pulse>
    <Time>2011-12-12T18:07:03.843</Time>
  </PulseOxReading>
  <PulseOxReading z:Id="i3" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
    <EntityKey z:Id="i4" xmlns="http://schemas.datacontract.org/2004/07/System.Data.Objects.DataClasses"
               xmlns:a="http://schemas.datacontract.org/2004/07/System.Data">
      <a:EntityContainerName>PulseOxDatabaseEntities</a:EntityContainerName>
      <a:EntityKeyValues>
        <a:EntityKeyMember>
          <a:Key>Id</a:Key>
          <a:Value i:type="b:int" xmlns:b="http://www.w3.org/2001/XMLSchema">6</a:Value>
        </a:EntityKeyMember>
      </a:EntityKeyValues>
      <a:EntitySetName>PulseOxReadings</a:EntitySetName>
    </EntityKey>
    <Id>6</Id>
    <Name>TestName-4</Name>
    <OxygenSaturation>99</OxygenSaturation>
    <Pulse>63</Pulse>
    <Time>2011-12-12T18:07:12.813</Time>
  </PulseOxReading>
  <PulseOxReading z:Id="i5" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
    <EntityKey z:Id="i6" xmlns="http://schemas.datacontract.org/2004/07/System.Data.Objects.DataClasses"
               xmlns:a="http://schemas.datacontract.org/2004/07/System.Data">
      <a:EntityContainerName>PulseOxDatabaseEntities</a:EntityContainerName>
      <a:EntityKeyValues>
        <a:EntityKeyMember>
          <a:Key>Id</a:Key>
          <a:Value i:type="b:int" xmlns:b="http://www.w3.org/2001/XMLSchema">7</a:Value>
        </a:EntityKeyMember>
      </a:EntityKeyValues>
      <a:EntitySetName>PulseOxReadings</a:EntitySetName>
    </EntityKey>
    <Id>7</Id>
    <Name>TestName-4</Name>
    <OxygenSaturation>100</OxygenSaturation>
    <Pulse>65</Pulse>
    <Time>2011-12-12T18:07:22.813</Time>
  </PulseOxReading>
  <PulseOxReading z:Id="i7" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
    <EntityKey z:Id="i8" xmlns="http://schemas.datacontract.org/2004/07/System.Data.Objects.DataClasses"
               xmlns:a="http://schemas.datacontract.org/2004/07/System.Data">
      <a:EntityContainerName>PulseOxDatabaseEntities</a:EntityContainerName>
      <a:EntityKeyValues>
        <a:EntityKeyMember>
          <a:Key>Id</a:Key>
          <a:Value i:type="b:int" xmlns:b="http://www.w3.org/2001/XMLSchema">8</a:Value>
        </a:EntityKeyMember>
      </a:EntityKeyValues>
      <a:EntitySetName>PulseOxReadings</a:EntitySetName>
    </EntityKey>
    <Id>8</Id>
    <Name>TestName-4</Name>
    <OxygenSaturation>100</OxygenSaturation>
    <Pulse>64</Pulse>
    <Time>2011-12-12T18:07:32.813</Time>
  </PulseOxReading>
  <PulseOxReading z:Id="i9" xmlns:z="http://schemas.microsoft.com/2003/10/Serialization/">
    <EntityKey z:Id="i10" xmlns="http://schemas.datacontract.org/2004/07/System.Data.Objects.DataClasses"
               xmlns:a="http://schemas.datacontract.org/2004/07/System.Data">
      <a:EntityContainerName>PulseOxDatabaseEntities</a:EntityContainerName>
      <a:EntityKeyValues>
        <a:EntityKeyMember>
          <a:Key>Id</a:Key>
          <a:Value i:type="b:int" xmlns:b="http://www.w3.org/2001/XMLSchema">9</a:Value>
        </a:EntityKeyMember>
      </a:EntityKeyValues>
      <a:EntitySetName>PulseOxReadings</a:EntitySetName>
    </EntityKey>
    <Id>9</Id>
    <Name>TestName-4</Name>
    <OxygenSaturation>99</OxygenSaturation>
    <Pulse>61</Pulse>
    <Time>2011-12-12T18:07:42.813</Time>
  </PulseOxReading>
</ArrayOfPulseOxReading>

The forgoing data could be parsed by various scripting languages for display by a Web browser.  Since the project we use to implement the REST Web service contains the SQL Server Express database with the data after it is generated by posts from the PulseOximeter, we can create an ASP.NET WebForm and access the data using the Entity Data Source control for display by a GridView control.

The following illustration shows the controls on the Visual Studio design surface.

Entity Data Source and GridView Controls

The controls on the page include a TextBox for entry of the subject’s name; name is used in the Where clause to get data for a single subject.  The following code shows the TextBox1_TextChanged event handler. When the user enters a name and presses Enter, the code in the handler generates an entity query for all readings where name equals the name in the TextBox. The query loads the Entity Data Source and returns only the Pulse Oximeter readings for the given name.

using System;

namespace PulseOxData
{
    public partial class PulseOxDisplay : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {

        }

        protected void TextBox1_TextChanged(object sender, EventArgs e)
        {
            EntityDataSource1.Where = "it.Name = '" + TextBox1.Text + "'";
        }
    }
}

The following illustration shows the Web form running in a browser.