Is it possible to add filtering specifications?

[matteoscrugli]

Hello,
thanks for your work, I was wondering if it was possible to add the specifications of the High-pass and Low-pass filters (for example the cut-off frequency) to the Readme of the repository (or where you want). Through the schematic you have released and the AD8232 datasheet is it possible to calculate them, but it is not very comfortable for users. Thank you very much.

[playaspec]

A review of the schematic shows the values chosen to be identical to those in figure 66 of the datasheet. This board is a faithful implementation of reference design. Run those values through the formulas and post the result here. Maybe if this repo gets updated it'll get included in the update.

[franzbischoff]

Use this example with a 50hz filter:

#include <Arduino.h>

#define LO_PLUS 4
#define LO_MINUS 5

// 50 Hz Notch and sampling timing
const uint16_t FS_HZ = 1000; // fixed sampling rate [Hz]
const float F_NOTCH = 50.0f; // change to 60.0f if needed
const float Q_NOTCH = 30.0f; // higher = narrower band

// Normalized coefficients (RBJ) and biquad states
float b0n, b1n, b2n, a1n, a2n;
// rename states to avoid conflict with y0()/y1() from math.h
float x1 = 0, x2 = 0, y_prev1 = 0, y_prev2 = 0;

uint32_t sampleIntervalUs;
uint32_t nextSampleUs;

static void initNotch()
{
  float w0 = 2.0f * PI * F_NOTCH / FS_HZ;
  float cw = cos(w0);
  float alpha = sin(w0) / (2.0f * Q_NOTCH);
  float a0 = 1.0f + alpha;

  // bandstop (notch) RBJ, normalized by a0
  b0n = 1.0f / a0;
  b1n = (-2.0f * cw) / a0;
  b2n = 1.0f / a0;
  a1n = (-2.0f * cw) / a0;
  a2n = (1.0f - alpha) / a0;
}

// Utility function to send 1+ values (uint32_t) in a binary frame
static inline void sendFrame(const uint32_t *values, uint8_t count)
{
  // Start marker (2 bytes)
  Serial.write(0xAA);
  Serial.write(0x88);

  uint8_t checksum = 0;

  // Values (4 bytes each) + checksum
  for (uint8_t i = 0; i < count; ++i)
  {
    uint32_t v = values[i];
    Serial.write((uint8_t *)&v, sizeof(uint32_t));
    uint8_t *vb = (uint8_t *)&v;
    for (int b = 0; b < 4; ++b)
      checksum += vb[b];
  }

  Serial.write(checksum);
}

void setup()
{
  // initialize the serial communication:
  // Increase UART throughput
  Serial.setTxBufferSize(4096); // ESP32: larger buffer reduces blocking
  Serial.begin(115200);
  pinMode(LO_PLUS, INPUT);  // Setup for leads off detection LO +
  pinMode(LO_MINUS, INPUT); // Setup for leads off detection LO -
  // Sampling scheduler + notch init
  sampleIntervalUs = 1000000UL / FS_HZ;
  nextSampleUs = micros() + sampleIntervalUs;
  initNotch();
}

void loop()
{
  // Executes at the fixed rate FS_HZ
  if ((int32_t)(micros() - nextSampleUs) >= 0)
  {
    nextSampleUs += sampleIntervalUs;

    if ((digitalRead(LO_PLUS) == 1) || (digitalRead(LO_MINUS) == 1))
    {
      // Reset states to avoid transients while electrodes are off
      x1 = x2 = y_prev1 = y_prev2 = 0;
      // Send frame with zeros (raw=0, filtered=0)
      uint32_t payload[2] = {0u, 0u};
      sendFrame(payload, 2);
    }
    else
    {
      // Sample, filter (50 Hz notch), and send
      int raw = analogRead(A0);
      float x0 = (float)raw;
      float y_curr = b0n * x0 + b1n * x1 + b2n * x2 - a1n * y_prev1 - a2n * y_prev2;
      x2 = x1;
      x1 = x0;
      y_prev2 = y_prev1;
      y_prev1 = y_curr;

      // Clip to [0, 4095] before packing as uint32
      int32_t y_i = (int32_t)y_curr;
      if (y_i < 0) y_i = 0;
      if (y_i > 4095) y_i = 4095;

      uint32_t payload[2] = { (uint32_t)raw, (uint32_t)y_i };
      sendFrame(payload, 2);
    }
  }
}