Prowess Consulting recently had the opportunity to create a prototype of a neonatal, wearable Internet of Things (IoT) monitor using the Zephyr Project operating system (OS). While neonatal, wearable IoT monitors aren’t unique, our project took a new approach to an existing monitor originally designed by Neopenda.
Neopenda’s monitor tracks neonatal vital signs for:
- Heart rate
- Respiratory rate
- Blood-oxygen level
The Neopenda device is different from many monitors in that it was designed for use at understaffed care facilities in low- and middle-income countries, which often have a ratio of one nurse for up to 50 babies. To improve infant health and survival rates despite the low staffing, the Neopenda device sends alerts to nursing staffs’ phones or tablets any time an infant’s critical vital-sign thresholds are exceeded. It’s an incredible and innovative device that brings an accessible, life-saving solution to areas that need it most.
One of our clients approached us to adapt Neopenda’s code base to:
- Work with a board and sensors powered by the Zephyr Project real-time operating system (RTOS)
- Consume less power
The Zephyr Project (www.zephyrproject.org) is a small, scalable open-source RTOS for use on resource-constrained systems that support multiple architectures. Our client supports the governance and ecosystem of the Zephyr Project to help drive broader adoption of the Zephyr Project as a standard for open-source IoT solutions for low-power devices.
The Zephyr Project–based prototype we created demonstrates the use of the Zephyr Project RTOS and its ability to meet the requirements of resource-constrained, secure IoT devices.
Our resulting prototype device is a combination of hardware (an Arduino 101 board, sensors, wires, and cables), software, and code—some from Neopenda’s existing monitor, with other code developed by Prowess specifically for the project.
The criteria our device needed to meet were to:
- Transmit patient vital signs using Bluetooth Low Energy (BLE)
- Receive transmitted data via an application on a device running the Android OS
- Display histories for blood-oxygen level and heart rate
Using these criteria, our engineers at Prowess worked not only to build the hardware board, but also to develop all the code to run the prototype. Our engineers took the peripheral heart-rate example as a starting point to get an actual heart-rate measurement working with BLE. From there, they developed the temperature measurement and the pulse-oximeter (blood-oxygen) measurement. The respiration-rate measurement used Neopenda’s existing calculation and algorithm by simply porting it over to the Zephyr Project prototype.
The resulting final prototype device captures, processes, and relays data points from sensors embedded in a band attached to the patient’s finger to an Android OS–based device. Data points are advertised by the device’s onboard BLE chipset, which allows an Android OS–based mobile application to visualize data as it is received from the sensors.
Do It Yourself
The build instructions and source code developed for the Zephyr Project prototype are included here, in case you want to try your hand at developing your own prototype or leverage parts of our work for your own project.
- For building the ble_core.img, follow the directions at https://wiki.zephyrproject.org/view/arduino_101#bluetooth_firmware_for_the_arduino_101.
- For building the Zephyr Project application, go to https://github.com/zephyrhealthproject/zephyr/tree/master/samples/bluetooth/peripheral_health_sensor
- For x86 app, go to: $ make pristine && make CONF_FILE=prj_x86_nimble.conf BOARD=arduino_101_factory
- For the ARC sensor module, go to: $ make pristine && make BOARD=arduino_101_sss_factory ARCH=arc
Arduino 101/Zephyr Firmware
- Source code for the Arduino 101/Zephyr firmware can be found at https://github.com/zephyrhealthproject/zephyr.
- The path begins at samples/bluetooth/peripheral_health_sensor (https://github.com/zephyrhealthproject/zephyr/tree/master/samples/bluetooth/peripheral_health_sensor).
- The code includes the Pulsesensor.com heart-rate algorithm, Neopenda’s respiration-rate calculation and algorithm, and digital-signal-processing (DSP) measurements for heart rate, temperature, blood oxygen, and respiration rate, in addition to BLE profiles for heart rate (HRS), pulse oximeter (SpO2), and health thermometer (HTS).
- The Synopsys ARC core is responsible both for processing the analog and digital sensor values and for providing results to the x86 core.
- The x86 core is responsible for setting up and configuring the BLE peripheral radio and for sending the health measurements to the BLE central device (with the Android application).
Android Application Based on the nRF Toolbox
- Source code for the Android application can be found at https://github.com/zephyrhealthproject/android.
- The relevant activities for the Android application are HRSActivity.java, HTSActivity.java, and SPO2Activity.java. These activities include the BLE profiles to receive the HRS, respiratory-rate, SpO2, and HTS results and to display them in the graphical interface.
- Intel Arduino 101 board
- Enclosure for Arduino board
- Adafruit Perma-Proto board
- One piece of CAT5/CAT5e/CAT6 cable, between 12 inches and 18 inches in length
- Two 470-ohm, 0.25-watt resistors
- One 660-nm, 3.3-VDC powered LED, high output
- One 940-nm LED (QEE113)
- One TSL235R-LF detector
- One TMP36GT9Z sensor
- One pulse sensor (pulsesensor.com)
- One 9-V battery connector
- One 9-V battery
- One barrel connector (2.1-mm ID-center conductor)
- Approximately 16-inch length of 0.5-inch diameter shrink wrap
- Approximate 6-inch length of 0.0625-inch shrink wrap
- One 1 x 40, right-angle make header pin row, break-away style
- One 2-inch x 4-inch Velcro strip
- Wire cutters
- Wire strippers
- Heat gun
- Small Phillips screwdriver
- Small flathead screwdriver
- Small needle-nose pliers
- Soldering station
- Hot-glue gun
- Assemble the enclosure kit around the Intel Arduino 101 board.
a. Before installing the top plate, drill a small hole to allow access to the master reset switch on the board.
- Cut the Adafruit Perma-Proto board down the middle between the two mount holes, making two separate small breadboards as shown in Figures 4 and 5.
- Take the 1 x 40 right-angle male header pin row and break off a single 14-pin length.
- Cut off a piece of CAT5 cable on each end equal to the length of the wiring supplied with the pulse sensor.
a. Remove the jacket to expose approximately 2 to 3 inches of the wires.
b. Untwist the wires and straighten them as much as possible. See Figure 6.
- Strip off approximately 0.25 inches of the insulation on all eight straightened wires on one side of the cable, leaving the wires on the other side intact.
- Cut off the prefabricated pins on the pulse sensor and strip back approximately 0.25 inches of the insulation, exposing the wires. If necessary, separate the wires from each other for about 1-2 inches of the length of the sensor cable.
- Take the 14-pin connector and plug it into the pin rows for power and analog, orienting it so that the pins point away from the interior of the Arduino 101 board.
a. Insert the long, right-angle leads into the board, leaving the shorter end pointing away from the board.
b. Leave pin A5 empty; all other pin sockets should be used with the 14-pin connector.
- Solder on the wires from the CAT 5 cable and pulse-sensor cable, following this pinout (see Figure 7):
a. A4 green
b. A3 purple (pulse sensor)
c. A2 blue/white
d. A1 green/white
e. A0 brown
g. GND—black (pulse sensor)
i. 5 V—orange
j. 3 V—red (pulse sensor)
k. The blue and brown/white wires in the CAT 5 cable are not used; trim them flush with the cable jacket.
- Cut off a small piece of 0.0625-inch shrink wrap, and then slide it on to each wire. This will help reduce interference or shorts.
a. Once the solder for each wire is complete, slide it down over the pin and wire the solder joint, using a small heat source to shrink the wrap around it.
- Thread the pulse sensor and the CAT5 cable through a 15- to 16-inch-long piece of 0.5-inch diameter shrink wrap.
a. Apply heat to the shrink wrap to compress the wrap around the two cables.
- Solder the components on to the breadboard, taking care to ensure that all sensors and LEDs are oriented in a straight line across the breadboard as shown in Figure 8.
- Solder the wires from the CAT5 cable onto the breadboard, using the following connection list (see Figure 9):
a. Blue/white—QEE13 940NM LED
b. Green/white—TSL235R-LF detector
c. Brown—red LED positive
d. Orange—red positive bar
e. Orange/white—blue negative bar
- Take the 2-inch x 4-inch Velcro strip and apply the two adhesive backs together so that there is one “hook” and one “loop” side of the Velcro attached back-to-back.
a. Trim off any exposed adhesive areas.
- Using the hot-glue gun, apply a large bead of glue to the “hook” side of the center Velcro strip, ensuring that it is large enough to adhere the strip to a significant portion of the back of the sensor breadboard.
a. Press the breadboard down firmly on the strip, and allow the glue to set.
- On the pulse sensor, apply one of the clear adhesive discs to the side that will make contact with the infant’s finger.
a. Apply a bead of hot glue to the back of the pulse sensor.
b. Apply one of the two supplied small Velcro discs to the glue, and allow the glue to set.
c. Once the glue is set, attach the Velcro strip attached to the sensor breadboard to the Velcro disk on the pulse sensor.
The finished result is shown in Figure 10.
- Test the fit of the Velcro straps by placing them around your index and middle fingers.
- Solder on the 9-V battery connector to a 2.1-mm ID center conductor barrel connector, orienting the positive on the center conductor and negative on the outer shell conductor.
- Power on the unit using the Arduino integrated development environment (IDE).