What is this project about
Why did I build it
How does it work
1. Sony AI Camera
2. Raspberry Pi 5 (Processing Pipeline
3. ThingSpeak Cloud
4. Display
Future improvements
Why this matters
Video Link: https://youtu.be/dhmUSxhS8pI

Published June 16, 2025 © GPL3+

FacePulse: Contactless Heart Rate Monitor

A real-time, contact-free heart rate monitoring system using facial video and AI.

IntermediateWork in progressOver 1 day146

FacePulse: Contactless Heart Rate Monitor

Things used in this project

Hardware components

Raspberry Pi 5

Sony AI Camera

Raspberry Pi Display Screen

3D Printing Case

Software apps and online services

Raspberry Pi OS (64-bit)

Python 3

OpenCV

Matplotlib

Hand tools and fabrication machines

3D Printer (generic)

Extraction Tool, 6 Piece Screw Extractor & Screwdriver Set

Story

What is this project about?

FacePulse is a real - time, non - contact heart rate monitoring system. It uses just a camera and AI to measure your heart rate from facial video—no wires, no wearables, no hassle.

By leveraging remote photoplethysmography (rPPG) (a technology where light interacts with blood in your skin; as your heart beats, blood flow changes cause tiny, camera - detectable color shifts on your face), our system detects these subtle signals. These signals are then processed to reveal your heart rate in beats per minute (BPM)—all from a simple camera feed.

Why did I build it?

Traditional heart rate monitoring methods like ECG or pulse oximetry have drawbacks:

Require physical contact (uncomfortable for long - term use).
Not ideal for remote/home care setups.
Rely on expensive clinical equipment.

I wanted to create a system that is:

Contactless & hygienic: No skin contact means lower infection risk—perfect for shared or home care environments.
Affordable & portable: Built with low - cost hardware (Raspberry Pi + camera) so it’s accessible for personal or community use.
Versatile: Ideal for telemedicine (e.g., monitoring elderly relatives remotely), fitness tracking (no need to wear a chest strap), and even future expansions like stress detection.

This system also has the potential to support real - time stress detection, remote diagnostics, and smart health wearables in the future.

How does it work?

The FacePulse system has 4 key components:

1. Sony AI Camera

Captures high - resolution facial video. We chose it for its excellent skin - tone sensitivity and low - noise performance—critical for picking up tiny rPPG signals.

2. Raspberry Pi 5 (Processing Pipeline)

Face detection: Uses OpenCV (an open - source computer vision library) to identify and isolate your face from the video feed.
rPPG signal extraction: Focuses on the green channel of the video (hemoglobin in blood absorbs green light most strongly, making this channel best for detecting blood flow changes).
Heart rate calculation: Combines the CHROM algorithm (reduces motion “noise” from your face, like subtle head movements) and FFT (Fast Fourier Transform) (converts the rPPG signal into a heart rate reading by analyzing its frequency).

3. ThingSpeak Cloud

Receives your BPM data and stores it. This lets doctors, caregivers, or you track heart rate trends over time—even from another city.

4. Display

Shows real - time heart rate data so you get instant feedback.

Future improvements

We’re already testing upgrades to make FacePulse even better:

Smarter low - light compensation: Using AI to “brighten” and clean up video in dark rooms (e.g., bedrooms at night). Early tests show this could cut low - light errors by 30%.
AI - powered motion filtering: New machine learning models will ignore motion “noise” (like talking or smiling) to keep heart rate readings accurate—even if you move.
Diverse skin tone & lighting tests: We’re expanding tests across more skin tones and extreme lighting (sunlight, office lamps) to ensure everyone gets reliable results.

Why this matters

FacePulse turns a regular camera into a health tool. It’s for anyone who wants easy, contactless heart rate tracking—whether you’re monitoring a loved one, training for a marathon, or just curious about your health. And because it’s built on open - source tools (like OpenCV) and affordable hardware, it’s a project anyone can replicate or build on.

Video Link: https://youtu.be/dhmUSxhS8pI

Custom parts and enclosures

Sketchfab still processing.

Schematics

Code

Untitled file

import os
import cv2
import numpy as np
import datetime
import matplotlib.pyplot as plt
import urllib.parse
import urllib.request
import http.client
from picamera2 import Picamera2
from scipy.fftpack import fft, fftfreq, fftshift
from scipy.signal import butter, filtfilt, savgol_filter

# Force the use of software rendering for OpenGL to avoid GPU issues
os.environ["LIBGL_ALWAYS_SOFTWARE"] = "1"

# ThingSpeak API Key for sending heart rate data
key = "LU7D22MJ8AWQ0XMA"
def send_to_thingspeak(hrate):
    """Send heart rate data to ThingSpeak cloud server."""
    params = urllib.parse.urlencode({'field1': hrate, 'key': key})
    headers = {"Content-type": "application/x-www-form-urlencoded", "Accept": "text/plain"}
    conn = http.client.HTTPConnection("api.thingspeak.com:80")
    try:
        conn.request("POST", "/update", params, headers)
        response = conn.getresponse()
        print(f"Heart Rate Sent: {hrate:.2f} bpm - Response: {response.status} {response.reason}")
        conn.close()
    except:
        print("Failed to send data to ThingSpeak")

def apply_chrom(rgb_seq, fs):
    """Extracts heart rate signal using the CHROM method."""
    rgb_seq = np.array(rgb_seq)
    B, A = butter(3, [0.7 / (fs / 2), 2.5 / (fs / 2)], btype='band')

    # Define chrominance signals
    X = 3 * rgb_seq[:, 0] - 2 * rgb_seq[:, 1]
    Y = 1.5 * rgb_seq[:, 0] + rgb_seq[:, 1] - 1.5 * rgb_seq[:, 2]

    # Apply bandpass filter
    Xf = filtfilt(B, A, X)
    Yf = filtfilt(B, A, Y)
    alpha = np.std(Xf) / np.std(Yf)
    S = Xf - alpha * Yf
    return S

# Initialize PiCamera settings
picam2 = Picamera2()
picam2.preview_configuration.main.size = (720, 480)
picam2.preview_configuration.main.format = "RGB888"
picam2.preview_configuration.controls.FrameRate = 30
picam2.configure("preview")
picam2.start()

# Load Haar Cascade for face detection
face_cascade = cv2.CascadeClassifier('/usr/share/opencv4/haarcascades/haarcascade_frontalface_default.xml')

# Initialize variables
frame_num = 0
RGB = []
time_stamps = []
bpm = 0
plt.ion()

# Start real-time heart rate detection
while True:
    frame = picam2.capture_array()
    gray = cv2.cvtColor(frame, cv2.COLOR_RGB2GRAY)
    faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

# Process heart rate after collecting sufficient frames
if frame_num >= 300:
    N = 300
    fs = frame_num / (time_stamps[-1] - time_stamps[0]).total_seconds()
    T = 1 / fs

    # Extract CHROM signal
    rgb_segment = np.array(RGB[-N:])
    chrom_signal = apply_chrom(rgb_segment, fs)
    chrom_signal = savgol_filter(chrom_signal, window_length=31, polyorder=3)

    # Perform FFT to analyze frequency components
    yf = fft(chrom_signal) / np.sqrt(N)
    xf = fftfreq(N, T)
    xf = fftshift(xf)
    yplot = fftshift(abs(yf))

    # Identify dominant frequency in the valid heart rate range
    valid_range = (xf >= 0.75) & (xf <= 4)
    valid_indices = np.where(valid_range)[0]
    max_idx = valid_indices[np.argmax(yplot[valid_indices])]
    bpm_freq = xf[max_idx]
    bpm = bpm_freq * 60 + 30  # Convert frequency to BPM

Credits

Peifeng Xia

1 project • 0 followers

Thanks to OpenCV team, SciPy Developers, NumPy Developers, and Matplotlib Development Team.

FacePulse: Contactless Heart Rate Monitor