HS-S70P 心跳傳感器

HS-S70P 心跳傳感器

1、介紹

心臟感應器是一種用於監測心臟跳動頻率和節律的電子設備，廣泛應用於醫療健康、運動健身、智能穿戴等領域。

2、原理圖

心率監測器-HS-S70P 原理圖點擊查看

3、模組參數

引腳名稱

描述

GND

GND（電源輸入負極）

VCC

VCC（電源輸入正極）

A

IIC資料傳輸引腳

L

IIC通訊時鐘引腳

  • 供電電壓：3.3V - 5V

  • 連接方式：PH2.0 4P端子線

  • 安裝方式：螺絲固定

4、電路板尺寸

5、Arduino IDE示範程序

注意：程式上傳時如果提示庫文件報錯，請先導入庫文件！
Arduino IDE 庁件文件下載及導入教範：點擊查看

示範程序（UNO開發板）：

#include <Wire.h>
#include "MAX30105.h"
#include "heartRate.h"

MAX30105 particleSensor;
const byte RATE_SIZE = 4; //Increase this for more averaging. 4 is good.
 byte rates[RATE_SIZE]; //Array of heart rates
 byte rateSpot = 0;
 long lastBeat = 0; //Time at which the last beat occurred
 float beatsPerMinute;
 int Bpm_value;

void setup(){
  Serial.begin(9600);
  particleSensor.begin(Wire, I2C_SPEED_FAST);
  particleSensor.setup(); //Configure sensor with default settings
  particleSensor.setPulseAmplitudeRed(0x0A); //Turn Red LED to low to indicate sensor is running
  particleSensor.setPulseAmplitudeGreen(0); //Turn off Green LED

}

void loop(){
  long irValue = particleSensor.getIR();
  if (checkForBeat(irValue) == true)
    {
      //We sensed a beat!
      long delta = millis() - lastBeat;
      lastBeat = millis();
      beatsPerMinute = 60 / (delta / 1000.0);
      if (beatsPerMinute < 255 && beatsPerMinute > 20)
      {
        rates[rateSpot++] = (byte)beatsPerMinute; //Store this reading in the array
        rateSpot %= RATE_SIZE; //Wrap variable
        //Take average of readings
  Bpm_value = 0;
        for (byte x = 0 ; x < RATE_SIZE ; x++)
  Bpm_value += rates[x];
  Bpm_value /= RATE_SIZE;
      }
    }
    Serial.print("Bpm_value = ");
    Serial.print(Bpm_value);
    Serial.println(" bpm");

}

6、ESP32 Python 示例（適用於Mixly IDE /米思齊）

開發板選擇 Python ESP32 【ESP32 Generic(4MB)】切換為代碼模式上傳

注意：程式上傳時如果提示庫文件報錯，請先導入庫文件！
米思齊（Mixly）IDE ESP32庫檔案下載及匯入教學：點擊查看

示例程式（ESP32-Python）：

from machine import I2C, Pin
import time

MAX3010X_I2C_ADDR = 0x57
REG_FIFOWRITEPTR   = 0x04
REG_FIFOOVERFLOW   = 0x05
REG_FIFOREADPTR    = 0x06
REG_FIFODATA       = 0x07
REG_FIFOCONFIG     = 0x08
REG_MODECONFIG     = 0x09
REG_PARTICLECONFIG = 0x0A
REG_LED1_PA        = 0x0C
REG_LED2_PA        = 0x0D
REG_MULTILEDCONFIG1= 0x11
REG_MULTILEDCONFIG2= 0x12
REG_PARTID         = 0xFF
EXPECTED_PARTID    = 0x15

def _mask_write(i2c, addr, reg, mask, bits):
    cur = i2c.readfrom_mem(addr, reg, 1)[0]
    cur &= mask
    cur |= bits
    i2c.writeto_mem(addr, reg, bytes([cur]))

class MAX3010x:
    def __init__(self, i2c, address=MAX3010X_I2C_ADDR):
        self.i2c = i2c
        self.address = address

    def read_reg(self, reg):
        return self.i2c.readfrom_mem(self.address, reg, 1)[0]

    def write_reg(self, reg, val):
        self.i2c.writeto_mem(self.address, reg, bytes([val & 0xFF]))

    def soft_reset(self):
        _mask_write(self.i2c, self.address, REG_MODECONFIG, 0xBF, 0x40)
        t0 = time.ticks_ms()
        while time.ticks_diff(time.ticks_ms(), t0) < 100:
            if (self.read_reg(REG_MODECONFIG) & 0x40) == 0:
                return True
            time.sleep_ms(1)
        return False

    def setup(self):
        self.soft_reset()
        _mask_write(self.i2c, self.address, REG_FIFOCONFIG, 0b11100000, 0x40)
        _mask_write(self.i2c, self.address, REG_FIFOCONFIG, 0xEF, 0x10)
        _mask_write(self.i2c, self.address, REG_MODECONFIG, 0xF8, 0x03)
        _mask_write(self.i2c, self.address, REG_PARTICLECONFIG, 0x9F, 0x60)
        _mask_write(self.i2c, self.address, REG_PARTICLECONFIG, 0xE3, 0x00)
        _mask_write(self.i2c, self.address, REG_PARTICLECONFIG, 0xFC, 0x03)
        self.write_reg(REG_LED1_PA, 0x4F)
        self.write_reg(REG_LED2_PA, 0x4F)
        _mask_write(self.i2c, self.address, REG_MULTILEDCONFIG1, 0xF8, 0x01)
        _mask_write(self.i2c, self.address, REG_MULTILEDCONFIG1, 0x8F, 0x20)
        self.write_reg(REG_FIFOREADPTR, 0)
        self.write_reg(REG_FIFOOVERFLOW, 0)
        self.write_reg(REG_FIFOWRITEPTR, 0)

    def read_fifo_red_ir(self):
        if self.read_reg(REG_FIFOREADPTR) == self.read_reg(REG_FIFOWRITEPTR):
            return None
        data = self.i2c.readfrom_mem(self.address, REG_FIFODATA, 6)
        red = ((data[0] << 16) | (data[1] << 8) | data[2]) & 0x3FFFF
        ir  = ((data[3] << 16) | (data[4] << 8) | data[5]) & 0x3FFFF
        return red, ir

lastBeatTime = 0
threshold = 2000
peak = 0
trough = 999999
amp = 0
IBI = 600
firstBeat = True
secondBeat = False
rate = [600] * 10
rate_index = 0

def checkForBeat(ir_value):
    global threshold, peak, trough, amp
    global lastBeatTime, firstBeat, secondBeat
    global IBI, rate, rate_index
    now = time.ticks_ms()
    signal = ir_value
    if signal < threshold and signal < trough:
        trough = signal
    if signal > threshold and signal > peak:
        peak = signal
    if signal > threshold and (time.ticks_diff(now, lastBeatTime) > 300):
        IBI = time.ticks_diff(now, lastBeatTime)
        lastBeatTime = now
        if firstBeat:
            firstBeat = False
            secondBeat = True
            return False
        if secondBeat:
            secondBeat = False
            for i in range(len(rate)):
                rate[i] = IBI
        rate[rate_index] = IBI
        rate_index = (rate_index + 1) % len(rate)
        amp = peak - trough
        threshold = trough + amp * 0.5
        peak = threshold
        trough = threshold
        return True
    if time.ticks_diff(now, lastBeatTime) > 2500:
        threshold = signal * 0.97
        peak = threshold
        trough = threshold
        firstBeat = True
        secondBeat = False
    return False

def read_bpm(timeout_ms=8000):
    i2c = I2C(1, scl=Pin(22), sda=Pin(21), freq=400000)
    sensor = MAX3010x(i2c)
    sensor.setup()
    start = time.ticks_ms()
    while time.ticks_diff(time.ticks_ms(), start) < timeout_ms:
        data = sensor.read_fifo_red_ir()
        if not data:
            time.sleep_ms(5)
            continue
        red, ir = data
        if ir < 20000:
            continue
        if checkForBeat(ir):
            avg_IBI = sum(rate) / len(rate)
            bpm = 60000 / avg_IBI
            new_bpm = bpm - 80
            if new_bpm < 0:
                return 0
            else:
                return int(new_bpm)
    return 0

import machine


while True:
    xinlv = read_bpm()
    print(('心率值（BMP）：' + str(xinlv)))

7、米思齊 Mixly 示例程式（圖形化語言）

示範程序（UNO開發板）：點擊下載
注意：程式上傳時如果提示庫文件報錯，請先導入庫文件！
米思齊（Mixly）IDE Arduino 圖庫檔案下載及匯入教學：點擊查看

示範程序（ESP32開發板）：點擊下載
注意：程式上傳時如果提示庫文件報錯，請先導入庫文件！
米思齊（Mixly）IDE ESP32庫檔案下載及匯入教學：點擊查看

8、測試環境搭建

Arduino UNO 測試環境搭建

準備配件：

  • HELLO STEM UNO R3 開發板 *1

  • HELLO STEM UNO 擴展板 *1

  • USB type-c 資料線 *1

  • 心率監測器模塊(HS-S70-P)*1

  • PH2.0 4P端子線 *1

電路接線圖：待更新．．．

ESP32 測試環境搭建

準備配件：

  • ESP32EA MOC 開發板 *1

  • ESP32-EXP1 扩展板 *1

  • USB type-c 資料線 *1

  • 心率監測器模塊(HS-S70-P)*1

  • PH2.0 4P端子線 *1

電路接線圖：待更新．．．

9、視頻教學

視頻教學：點擊查看

10、測試結果

Arduino UNO測試結果：

待更新．．．

ESP32 測試結果：

器件連接好線之後，將上述程序上傳到開發板之後，即可看到心臟感應器模組數據測試。

粤ICP备2026021056号 © 2020-2026 Hellostem 程序所有權利保留，創建於Hellostem