void pulse(bool state) {
  uint16_t length = 200;
  if (state) {
    length = 500;
  }
  for (size_t i = 0; i < length; i++) {
    Serial.println(1023);
  }
  for (size_t i = 0; i < 1000 - length; i++) {
    Serial.println(0);
  }
}

template <size_t n> void plot(double const (& data)[n]) {
  for (double const& datum: data) {
    Serial.println(datum);
  }
}


double smooth(double const sample, double const weight) {
  static double average {sample};
  average = (1 - weight) * average + weight * sample;
  return average;
}


void setup() {
  Serial.begin(9600);

  uint8_t const signal[] {0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1};
  plot(signal);
}

void loop() {
  if (not Serial.available()) {
    return;
  }
  uint8_t sample = Serial.read() - '0';
  delay(100);
  while (Serial.available()) {
    Serial.read();
  }

  Serial.print(sample);
  Serial.print(' ');
  Serial.println(smooth(sample, 0.1));
}

sketch.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

libraries.txt

#pragma once


inline void mPrint(Stream&) {}

template <class H, class... Tail> void mPrint(Stream& stream, H const head, Tail const... tail) {
  stream.print(head);
  mPrint(stream, tail...);
}

template <class... Args> void mPrintln(Stream& stream, Args const... args) {
  mPrint(stream, args..., "\r\n");
}

/* Example.
mPrintln(Serial, "This would normally take ", 3, " lines.");
*/

mprint.h

#pragma once


template <class T> String show(T const) {
  String s(__PRETTY_FUNCTION__);

  return s.substring(25, s.length() - 1);
}

/* Example.
Serial.println(show(analogRead));
*/

show.h

#pragma once


template <class T, size_t n> size_t arraySize(T const (&)[n]) { return n; }

/* Example.
int myArray[] = {0, 1, 2, 3, 4};
Serial.println(arraySize(myArray));
*/

array.h

#pragma once


struct seconds {
  unsigned long x;
};

struct milliseconds {
  unsigned long x;
};

constexpr seconds operator"" s(unsigned long long x) {
  return seconds{x};
}

constexpr milliseconds operator"" ms(unsigned long long x) {
  return milliseconds{x};
}

types.h

#pragma once


template <size_t N>
void parseLine(int (&result)[N], char const line[]) {
  char* endptr = const_cast<char*>(line);
  for (size_t i = 0; i < N and endptr[0]; i++) {
    result[i] = strtol(endptr + static_cast<int>(i != 0), &endptr, 10);
  }
}

template <size_t N>
void parseLine(double (&result)[N], char const line[]) {
  char* endptr = const_cast<char*>(line);
  for (size_t i = 0; i < N and endptr[0]; i++) {
    result[i] = strtod(endptr + static_cast<int>(i != 0), &endptr);
  }
}

/* Examples.
char const line[] = "12, 3, 123";
int result[3];
parseLine(result, line);
for (int const& value: result) {
  Serial.println(value);
}

char const line[] = "1.2, 3, 12.3";
double result[3];
parseLine(result, line);
for (double const& value: result) {
  Serial.println(value);
}
*/

parse.h

#pragma once


class C {
  int data_ = 10;
public:
  void print() {
    Serial.println(data_);
  }
};

/* Example:
void test(C& obj, void (C::*f)()) {
 (obj.*f)();
}

void setup() {
  Serial.begin(9600);

  C c;
  test(c, &C::print);
}
 */