Measure SpO2, Heart Rate and BP Trends Using Arduino [Accurate]

Overview

In this project, you will build a compact Arduino-based vital signs monitor that measures:

• Blood oxygen saturation (SpO₂)
• Heart rate (HR)
• Blood pressure trends (BPT) – systolic and diastolic estimates

Instead of processing raw photoplethysmogram (PPG) signals yourself, we’ll use the ProtoCentral Pulse Express board. It combines:

• A MAX30102 optical pulse oximeter and heart‑rate sensor
• A MAX32664D biometric sensor hub with built‑in algorithms

The MAX32664D runs Maxim’s health algorithms and provides SpO₂, heart rate, and estimated BP values over I²C. All your Arduino has to do is read the results and display them on a small OLED screen (and optionally the Serial Monitor).

This is an excellent project for:

• Learning biomedical sensing and PPG-based vitals monitoring
• Building a wearable health/wellness gadget
• Creating a platform for further experimentation (data logging, BLE, dashboards, etc.)

Important safety note:

• The Pulse Express board and this project are intended for education, research, and development.
• They are NOT certified medical devices and should NOT be used for diagnosis or treatment.

---

Required Components

Here’s what you need to build this project:

Core modules:

• 1× Arduino Uno (or Nano/Nano 33 BLE)
• 1× ProtoCentral Pulse Express Pulse‑Ox & Heart Rate Sensor with MAX32664 (PC‑MED‑0411)
• 1× 0.96″ or 1.3″ I²C OLED display (128×64 SSD1306-based, usually 0x3C address)

Power and connections:

• USB cable for Arduino
• Breadboard and jumper wires (male‑to‑male, male‑to‑female as needed)
• 5 V power supply (USB or external, if needed)

Optional but recommended:

• Velcro strap or 3D‑printed finger holder for stable measurements
• A reference clinical BP cuff and a medical‑grade pulse oximeter for better calibration

Libraries (to be installed in Arduino IDE):

• ProtoCentral Pulse Express Arduino Library
• Adafruit SSD1306 and Adafruit GFX libraries for the OLED

---

About the Sensors

ProtoCentral Pulse Express Board

The ProtoCentral Pulse Express is a compact breakout designed for finger‑based PPG measurements. It integrates two key chips and is made to be very easy to use with Arduino or any other microcontroller.

Key features:

• Integrates a high‑sensitivity pulse oximeter and heart‑rate sensor (MAX30102).
• Integrated biometric sensor hub (MAX32664D).
• Built‑in accelerometer (on some versions) to help reduce motion artifacts.
• Easy I²C interface to connect to any host MCU.
• Ultra‑low power design, suitable for wearable applications.
• Built‑in algorithms estimate:
  • Heart rate
  • SpO₂
  • Blood pressure trends (estimated systolic and diastolic).

ProtoCentral emphasizes that:

• The device is only meant for research & development.
• It is NOT a medical device and is not approved as such.

They also provide:

• Arduino library (GitHub)
• ProtoCentral OpenView GUI to visualize PPG and vitals on a PC

MAX30102 – Pulse Oximeter & Heart Rate Sensor

The MAX30102 is an integrated pulse oximeter and heart‑rate sensor module from Maxim (now Analog Devices). It is designed specifically for mobile and wearable devices.

Highlights:

• Contains:
  • Red and infrared LEDs
  • Photodetector
  • Optical elements and low‑noise analog front end with ambient light rejection
    analog
• Uses reflective pulse oximetry: the LEDs and detector are on the same side, so the sensor can be placed on a finger, wrist, or earlobe.
• Communicates via I²C.
• Very low power; supports software shutdown with near‑zero standby current.
  analog

In this board, the MAX30102’s job is to:

• Shine red and IR light into your finger
• Capture the reflected light variations (PPG waveform) caused by blood volume changes

MAX32664D – Biometric Sensor Hub

The MAX32664 is a family of ultra‑low‑power sensor hubs with embedded health algorithms. Version D (MAX32664D) is specifically targeted for:

• Finger‑based measurement of:
  • Heart rate
  • SpO₂
  • Estimated blood pressure trends

What it does:

• Reads raw PPG data from the MAX30102 over its own master I²C bus.
• Runs Maxim’s algorithms on that data (heart rate, SpO₂, BP estimation).
• Provides processed outputs to a host microcontroller (Arduino) over a second I²C interface (where the hub acts as a slave).

Key features:

• Can directly interface to the MAX30101/MAX30102 optical sensors.
• Supports an accelerometer for motion artifact rejection (optional but very useful in wearables).
• Delivers:
  • Raw sensor data
  • Calculated vitals (HR, SpO₂, estimated systolic/diastolic BP) to the host MCU.
• Designed to keep power consumption low, which is crucial for battery‑operated devices.

In the ProtoCentral Pulse Express:

• MAX30102 captures the light signals.
• MAX32664D processes them using its algorithms.
• Your Arduino simply asks for the results – no complex PPG processing on your side.

---

Connection Diagram with Arduino and OLED

The connections are straightforward because both the Pulse Express and the OLED use I²C.

Connect all the required components according to the above circuit diagram, also refer below table.

Pulse Express ↔ Arduino (I²C + control pins)

Pulse Express Pin	Arduino Uno/Nano Pin	Function
Vin	5 V	Power supply
GND	GND	Ground
SDA	A4	I²C Data
SCL	A5	I²C Clock
MFIO	D2	Multi‑function I/O / interrupt
RESET	D4	Reset for MAX32664

Notes:

• If you’re using a different Arduino board (e.g., Nano 33 BLE, Mega), make sure you use the correct SDA/SCL pins according to your board’s pinout.
• MFIO and RESET are digital pins used to control and reset the MAX32664D; the library expects you to define them at the top of the sketch (RESET_PIN and MFIO_PIN).

OLED Display ↔ Arduino (I²C)

A typical 0.96″ SSD1306 OLED with I²C usually connects as follows (for Uno/Nano):

Because the Pulse Express and the OLED use different addresses, they can share the same I²C bus:

• Pulse Express: MAX32664D/MAX30102 have their own I²C addresses managed by the hub.
• OLED: typically 0x3C for SSD1306-based displays.

Arduino-based vital signs monitor Working Flow diagram

Here’s a simple system overview diagram showing how everything is connected and how data flows.

This diagram represents:

• Physical connection:
  • Pulse Express ↔ Arduino via I²C + MFIO/RESET
  • OLED ↔ Arduino via I²C
• Logical flow:
  • PPG → algorithm → Arduino → OLED & Serial

---

Develop a High-Precision Health Sensor Platform with PCBWay’s Integrated Manufacturing

Build a sophisticated health monitoring research platform with PCBWay’s precision fabrication. Create a reliable prototype for capturing accurate SpO2, heart rate, and trend data using your Arduino and MAX32664 sensor—perfect for research, development, and advanced experimentation.

Research-Optimized PCB Assembly:
Design a unified board with specialized analog circuitry for clean signal acquisition from your MAX32664 sensor. Their 4-layer boards with controlled impedance and professional SMT assembly ensure minimal electrical noise in sensitive photoplethysmography (PPG) signal paths, while proper power conditioning maintains the stable voltage required for consistent sensor calibration and data collection.

Ergonomic 3D-Printed Enclosures:
Create comfortable, functional housings using engineering-grade 3D printing materials. Design with durable ABS or lightweight nylon to prototype wearable forms or handheld units. Incorporate precisely aligned sensor windows, ventilation features, and secure mounting points that optimize the sensor-skin interface for reliable data capture during extended testing sessions.

Why PCBWay Supports Superior Research Prototypes:

• Signal Integrity: Precision PCB manufacturing preserves microamp-level PPG signals from noise corruption
• Measurement Consistency: Stable power delivery and thermal management enhance data reliability
• Prototype Refinement: Custom enclosures allow iterative testing of sensor placement and user ergonomics
• Professional Results: Factory assembly ensures robust connections for repeated experimentation

Build Your Advanced Health Monitoring Prototype
Upload your sensor interface PCB design and enclosure files for expert manufacturing review and seamless production integration on PCBWAY.com

---

Connecting Arduino to PC, Installing Libraries, and Uploading Code

Hardware Setup

1. Place components on the breadboard:
   • Arduino
   • Pulse Express board
   • OLED display
2. Make the connections according to the tables above:
   • Double‑check:
     • 5 V and GND to Pulse Express and OLED
     • SDA/SCL lines correct
     • MFIO and RESET pins wired to the digital pins you’ll define in code
3. Connect the Arduino to your PC using the USB cable.

Install Arduino IDE

If you don’t already have it:

• Download the latest Arduino IDE from the official site and install it.

Install the ProtoCentral Pulse Express Library

Method 1 – Using Arduino Library Manager (recommended):

1. Open Arduino IDE.
2. Go to:
   • Sketch → Include Library → Manage Libraries…
3. In the search box, type:
   • “Protocentral Pulse Express”
4. Find the ProtoCentral Pulse Express library and click Install.

Method 2 – Manual install from GitHub:

1. Go to the ProtoCentral Pulse Express Arduino Library GitHub page.
2. Click “Code → Download ZIP”.
3. In Arduino IDE:
   • Sketch → Include Library → Add .ZIP Library…
   • Select the downloaded ZIP.

This library includes the example sketches (e.g., Example2‑BPT‑estimation‑mode) that we’ll adapt for OLED output.

Install Adafruit SSD1306 and Adafruit GFX Libraries

These are needed for the OLED:

1. In Arduino IDE, open Library Manager.
2. Search for and install:
   • “Adafruit SSD1306”
   • “Adafruit GFX”

Once installed, you’ll see many SSD1306 examples under File → Examples → Adafruit SSD1306.

Upload the Code

Below is a complete example sketch that:

• Uses the ProtoCentral Pulse Express library in BPT estimation mode.
• Displays SpO₂, HR, systolic BP, and diastolic BP on an SSD1306 OLED.
• Still prints values to Serial for debugging (you can remove that later if you want).

IMPORTANT:

• Adjust RESET_PIN and MFIO_PIN if you use different pins.
• Adjust OLED_RESET if your OLED module uses a different reset pin (many don’t, so -1 is common).
• Adjust I²C address (0x3C) if your OLED uses 0x3D.

Example code:

#include <Wire.h>
#include "max32664.h"
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// ---- OLED display settings ----
#define SCREEN_WIDTH  128
#define SCREEN_HEIGHT 64
#define OLED_RESET     -1          // Reset pin (-1 if sharing Arduino reset)
#define SCREEN_ADDRESS 0x3C        // Most 128x64 OLEDs use 0x3C
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT,
                         &Wire, OLED_RESET);

// ---- Pulse Express (MAX32664) pins ----
#define RESET_PIN 4
#define MFIO_PIN  2
#define RAWDATA_BUFFLEN 250

max32664 MAX32664(RESET_PIN, MFIO_PIN, RAWDATA_BUFFLEN);

// Calibration and SpO2 coefficients
// Replace these with your own cuff-based BP readings and SpO2 reference values.
void loadAlgorithmParameters() {
  algomodeInitialiser params;

  // Example: Systolic BP (mmHg) from a reference cuff
  params.calibValSys[0] = 120;
  params.calibValSys[1] = 122;
  params.calibValSys[2] = 125;

  // Example: Diastolic BP (mmHg) from a reference cuff
  params.calibValDia[0] = 80;
  params.calibValDia[1] = 81;
  params.calibValDia[2] = 82;

  // SpO2 calibration coefficients (example values)
  // You can refine these using a medical-grade SpO2 meter.
  params.spo2CalibCoefA = 1.5958422;
  params.spo2CalibCoefB = -34.659664;
  params.spo2CalibCoefC = 112.68987;

  MAX32664.loadAlgorithmParameters(&params);
}

void setup() {
  Serial.begin(57600);
  while (!Serial && millis() < 3000); // Wait for Serial (optional)

  Wire.begin(); // Initialize I2C

  // Initialize OLED
  if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));
    // Halt here if OLED fails to initialize
    for (;;);
  }

  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.println("Vitals Monitor");
  display.println("Initializing...");
  display.display();

  // Load BP & SpO2 calibration parameters
  loadAlgorithmParameters();

  // Initialize the MAX32664 sensor hub
  int result = MAX32664.hubBegin();
  if (result == CMD_SUCCESS) {
    Serial.println("Sensor hub begin!");
    display.println("Sensor hub OK");
  } else {
    Serial.println("Could not communicate with the sensor! Check connections.");
    display.println("Sensor fail!");
    display.display();
    // Stay here on failure
    while (1) {
      delay(5000);
    }
  }
  display.display();

  // Start BPT calibration
  bool ok = MAX32664.startBPTcalibration();
  if (!ok) {
    Serial.println("BPT calibration failed. Restart and try again.");
    display.clearDisplay();
    display.setCursor(0, 0);
    display.println("Calib failed!");
    display.println("Restart device.");
    display.display();
    while (1) {
      delay(1000);
    }
  }

  display.clearDisplay();
  display.setCursor(0, 0);
  display.println("Calibrating...");
  display.println("Keep finger still");
  display.display();

  // The algorithm runs calibration internally; here we wait until done.
  // In the ProtoCentral example, once calibration completes,
  // we switch to estimation mode.
  // Actual calibration duration is typically ~10–20 seconds.

  // Optional: simple fixed delay (you can improve with progress feedback)
  delay(10000);

  // Switch to estimation mode
  ok = MAX32664.configAlgoInEstimationMode();
  if (!ok) {
    Serial.println("Failed to enter estimation mode.");
    display.clearDisplay();
    display.setCursor(0, 0);
    display.println("Est mode failed!");
    display.println("Check sensor.");
    display.display();
    while (1) {
      delay(1000);
    }
  }

  display.clearDisplay();
  display.setCursor(0, 0);
  display.println("Estimating...");
  display.println("Place finger.");
  display.display();

  delay(1000);
}

void loop() {
  // Try to read new samples from the sensor hub
  uint8_t numSamples = MAX32664.readSamples();

  if (numSamples) {
    // Get vitals from the library's output structure
    uint8_t hr   = MAX32664.max32664Output.hr;       // heart rate
    uint8_t spo2 = MAX32664.max32664Output.spo2;     // SpO2 (%)
    uint8_t sys  = MAX32664.max32664Output.sys;      // estimated systolic BP (mmHg)
    uint8_t dia  = MAX32664.max32664Output.dia;      // estimated diastolic BP (mmHg)

    // Optional: print to Serial for debugging
    Serial.print("sys=");
    Serial.print(sys);
    Serial.print(", dia=");
    Serial.print(dia);
    Serial.print(", hr=");
    Serial.print(hr);
    Serial.print(", spo2=");
    Serial.println(spo2);

    // Update OLED
    display.clearDisplay();
    display.setCursor(0, 0);
    display.setTextSize(1);
    display.println("Vitals Monitor");

    display.println("------");

    display.print("HR:   ");
    display.print(hr);
    display.println(" bpm");

    display.print("SpO2: ");
    display.print(spo2);
    display.println(" %");

    display.println("BP Trend:");

    display.print("Sys:  ");
    display.print(sys);
    display.println(" mmHg");

    display.print("Dia:  ");
    display.print(dia);
    display.println(" mmHg");

    display.display();
  }

  // Small delay to avoid spamming the display/I2C too fast
  delay(100);
}

Key points about the code:

• It follows the same flow as Example2‑BPT‑estimation‑mode: calibration → estimation mode → reading samples.
• loadAlgorithmParameters fills the same calibration structure as the original example, but we display values clearly.
• hubBegin, startBPTcalibration, configAlgoInEstimationMode, and readSamples are the main MAX32664 library calls.
• OLED output is refreshed only when new samples are available to keep the display stable and readable.

---

How the Code Works

Let’s walk through the main steps in the code, matching how the sensor and library behave.

I²C Initialization

Wire.begin() initializes the I²C bus shared by:

• The Pulse Express board (MAX32664D/MAX30102)
• The OLED display (SSD1306)

Because they have different addresses, they coexist on the same bus.

OLED Initialization

We call:

display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);

This:

• Sets up the SSD1306 driver.
• Clears the display buffer.
• Prepares the screen for drawing text.

If this fails, the code halts and shows an error message on Serial and on the OLED itself.

Calibration Parameters

The function loadAlgorithmParameters:

• Creates an algomodeInitialiser structure defined in the library.
• Fills it with:
  • calibValSys[0..2]: three systolic BP values from a reference cuff.
  • calibValDia[0..2]: three diastolic BP values from a reference cuff.
  • spo2CalibCoefA/B/C: SpO₂ calibration coefficients, which you can tune against a medical SpO₂ meter.

Then:

MAX32664.loadAlgorithmParameters(&params);

sends these coefficients to the MAX32664D algorithm via I²C.

Sensor Hub Initialization

hubBegin():

• Initializes the MAX32664D sensor hub.
• Sets up communication with the MAX30102 optical sensor and prepares the algorithms.
• Returns CMD_SUCCESS if communication with the board is successful, or an error code otherwise.

If it fails, the code prints an error message and stops in a loop so you know something is wrong with the wiring or power.

6.5 BPT Calibration

startBPTcalibration():

• Commands the MAX32664D to start its blood pressure trending calibration routine.
• During calibration, you should:
  • Keep your finger still and gently placed on the sensor.
  • Sit quietly and avoid movement.
• The algorithm collects enough PPG samples to correlate with your reference calibration BP values.

After calling startBPTcalibration(), the sketch waits a short time and then calls configAlgoInEstimationMode(). In a full production‑style code, you could monitor the calibration progress from the hub status; here we keep it simple for clarity.

Switching to Estimation Mode

configAlgoInEstimationMode():

• Tells the MAX32664D to finish calibration and start running in estimation mode.
• In this mode, it continuously calculates:
  • Heart rate (hr)
  • SpO₂ (spo2)
  • Systolic BP estimate (sys)
  • Diastolic BP estimate (dia)

If this fails (for example, calibration did not complete correctly), the code halts with an error.

Reading Vitals in Loop()

In loop():

readSamples():

• Returns the number of new samples available.
• If > 0, the output structure MAX32664.max32664Output is updated with:
  • hr
  • spo2
  • sys
  • dia

The sketch then:

• Prints these values to Serial (useful for debugging).
• Updates the OLED display by:
  • Clearing the screen
  • Drawing labels (“HR”, “SpO2”, “BP Trend”, “Sys”, “Dia”)
  • Drawing the current numeric values
  • Calling display.display() to refresh the OLED

Finally, a small delay (100 ms) keeps the updates smooth without flooding the bus.

---

Applications

Once you have this basic prototype working, you can extend it in many directions:

• Personal health tracker:
  • Continuously monitor SpO₂ and heart rate while resting, walking, or exercising.
  • Track relative BP trends over time (not absolute clinical BP, but useful for observing patterns).
• Wearable device:
  • Move the design to a small Arduino‑compatible board (like Nano 33 BLE) powered by a Li‑Po battery.
  • Add Bluetooth or Wi‑Fi to send data to a smartphone app or cloud server.
• Lab/teaching tool:
  • Use it to demonstrate PPG waveforms and how optical sensors measure heart rate and SpO₂.
  • Show students the concept of calibration and trending vs. absolute measurements.
• Senior safety monitoring:
  • Combine with other sensors (temperature, movement) for a basic elderly monitoring system that raises alerts when vitals go outside safe ranges.
• Research platform:
  • Log data to SD card for analysis.
  • Experiment with different finger placements and sensor conditions.
  • Compare with clinical devices to understand error sources and limitations.

Always remember that this is an educational/development platform, not a replacement for certified medical devices.

---

Limitations

It’s important to understand the limitations of this system:

Not a certified medical device

• Pulse Express is explicitly marked for research & development only and not approved as a medical device.
• Never rely on it as the only basis for diagnosis or treatment.

BP trends, not absolute BP

• The MAX32664D BPT algorithm provides estimated blood pressure trends based on calibration and PPG shape changes.
• It is not a replacement for a sphygmomanometer (cuff‑based BP monitor).
• Accuracy depends heavily on:
  • Proper calibration
  • Stable conditions
  • Consistent sensor placement

Environmental and motion sensitivity

• PPG signals are affected by:
  • Ambient light
  • Finger movement and pressure
  • Skin perfusion, temperature, and user‑specific factors
• Even with an accelerometer and motion compensation (optional version), readings can degrade under heavy motion or poor finger contact.
  analog

Calibration effort

• To get reasonable BP trend accuracy:
  • You need at least a few reference cuff measurements.
  • You may need to recalibrate when:
    • Changing users
    • Changing the setup (e.g., strap, optical cover)
    • Environmental conditions change drastically

Sensor range and perfusion

• Very cold fingers, very low perfusion, or certain skin conditions can make it hard to acquire a good PPG signal.
• Nail polish or very thick skin can also reduce accuracy.

Algorithm assumptions

• Maxim’s algorithms are optimized for typical adult usage in wellness scenarios.
  mouser
• Performance may vary significantly with:
  • Children
  • Very different body types
  • Certain medical conditions

Display size and resolution

• A 128×64 OLED is small, so:
  • You must be careful with text layout.
  • Some detailed messages may need to be shortened or split across screens.

---

FAQ

Q1: Can I use a different Arduino board?
Yes. The key is:

• Use the correct I²C pins for your board (e.g., SDA/SCL on Mega, Leonardo, Nano 33 BLE).
• Define RESET_PIN and MFIO_PIN on available digital pins.
• Make sure your board can supply enough current (usually not an issue for a single sensor + OLED).

Q2: Why does SpO₂ always show around 99–100%?
Possible reasons:

• Ambient light leaking into the sensor.
• Optical characteristics of the enclosure or window (if you added a cover).
• SpO₂ calibration coefficients (spo2CalibCoefA/B/C) not tuned to your hardware or conditions.

ProtoCentral suggests adjusting the algorithm’s “R value” and coefficients when using optical covers or when readings are stuck at 100%. Refer to Maxim’s SpO₂ calibration guides for more details.

Q3: Can I skip calibration and still get BP values?

• You must at least load default calibration coefficients for the algorithm to run.
• Without proper cuff‑based calibration, the BP numbers are generic estimates and should be interpreted very cautiously. For better accuracy, always input your own reference measurements.

Q4: Why does the OLED not show anything?
Check:

• I²C wiring (SDA/SCL, power).
• I²C address: if your module uses 0x3D instead of 0x3C, change SCREEN_ADDRESS.
• That display.begin() returns true (the code already handles this).
• Try running a simple Adafruit SSD1306 example (like “ssd1306_128x64_i2c”) to confirm the OLED works.

Q5: Can I add Bluetooth or Wi‑Fi?
Yes. You can:

• Use boards like Arduino Nano 33 BLE, ESP32, or add a BLE/Wi‑Fi module.
• Send the vitals (hr, spo2, sys, dia) over BLE/Wi‑Fi to a mobile app or web server.

Just ensure that:

• Power supply is sufficient.
• Wireless communication doesn’t overwhelm the I²C bus or timing (you may need non‑blocking code).

Q6: Is this safe to use 24/7?

• For short experiments, demos, or occasional wellness checks, it’s generally fine.
• For long‑term wear, you must consider:
  • Comfort
  • Skin safety
  • Device reliability
• Always follow safe electronics practices and don’t leave it unattended for long periods while powered.

---

Conclusion

In this project, you learned how to:

• Use the ProtoCentral Pulse Express board (MAX30102 + MAX32664D) to measure:
  • SpO₂
  • Heart rate
  • Blood pressure trends (BPT) with Arduino
    analog
• Wire the board and an I²C OLED to an Arduino using a shared I²C bus.
• Install and use the ProtoCentral Pulse Express Arduino Library to run the BPT estimation mode.
• Display vitals in real time on an OLED screen while keeping serial output for debugging.

The combination of the MAX30102 optical sensor and MAX32664D sensor hub greatly simplifies PPG‑based vitals monitoring by offloading algorithm complexity to the sensor board. Your Arduino mostly acts as a display host and data logger, which makes this project accessible and powerful for:

• Learning bio‑sensing basics
• Prototyping wearable or bedside health monitors
• Building custom experiments and lab tools

Always remember:

• This is a research/development platform, not a medical device.
• Treat the readings as educational and indicative, not as diagnostic.
• Recalibrate carefully and be mindful of environmental and user‑specific factors.

With this foundation, you can now:

• Improve the enclosure and ergonomics
• Add wireless connectivity
• Log long‑term data
• Experiment with advanced analytics or cloud dashboards

…and take your Arduino‑based health monitoring projects to the next level.