#include <TimerOne.h>
#include <SPI.h>
#include "coeffs.h" // Incluye el archivo con los coeficientes

#define CS_DAC 10

// Driver for DAC TLC5616
class TLC5616 {
  int CS_pin;
  public:
    TLC5616(int _CS_pin) {
      CS_pin = _CS_pin;
    }
    void begin(void) {
      SPI.begin();
      pinMode(CS_pin, OUTPUT);
      digitalWrite(CS_pin, HIGH);
    }
    void write(uint16_t value) {
      value = (value & 0x3ff) << 2;
      digitalWrite(CS_pin, LOW);
      SPI.beginTransaction(SPISettings(20000000, MSBFIRST, SPI_MODE0));
      SPI.transfer16(value);
      SPI.endTransaction();
      digitalWrite(CS_pin, HIGH);
    }
};

#define N_MAX 9  // El número máximo de coeficientes que necesitas
float w[N_MAX];  // Vector de retardo (buffer de estado)

// Variables del temporizador y DAC
float fs = 8000;
float ts = 1 / fs;
unsigned long tick;
volatile int timerDone = 0;

TLC5616 dac(CS_DAC);

// Variables para medición del tiempo de cómputo
unsigned long startTime;
unsigned long endTime;
unsigned long computeTime;

// Inicializa el buffer de estado del filtro
void iniciar_filtro(int N) {
  for (int k = 0; k < N; k++) {
    w[k] = 0.0;
  }
}

// Filtrado en estructura directa tipo 2
float filtrar(float x_ADC, float *ak, float *bk, int N) { 
  int k;
  float yn, wn;

  wn = x_ADC;
  // Calcula el valor del elemento de retardo w[0]
  for (k = N - 1; k >= 1; k--) {
    wn -= ak[k] * w[k];
  }
  w[0] = wn;

  // Calcula la salida
  yn = 0;
  for (k = 0; k < N; k++) {
    yn += bk[k] * w[k];
  }

  // Realiza el movimiento de datos
  for (k = N - 1; k > 0; k--) {
    w[k] = w[k - 1];
  }

  return yn;
}

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

  tick = ts * 1000000;
  Timer1.initialize(tick);
  Timer1.attachInterrupt(Timer1_ISR);

  // DAC Initialization
  dac.begin();

  // Inicializar filtro para el número de coeficientes del filtro que elijas
  iniciar_filtro(N_b1);  // Inicialización Filtro
}

void loop() {
  while (!timerDone);
  timerDone = 0;
  int x = analogRead(A0); // Leer ADC

  // Medir tiempo antes de filtrar
  startTime = micros();  // Tiempo inicial en microsegundos

  // Aplicar los filtros secuenciales
  float filtered_signal = apply_filters(x-512); // "-512" si no es necesario

  // Medir tiempo después de filtrar
  endTime = micros();  // Tiempo final en microsegundos

  // Calcular el tiempo de cómputo
  computeTime = endTime - startTime;

  // Imprimir tiempo de cómputo
  Serial.print("Tiempo de cómputo: ");
  Serial.print(computeTime);
  Serial.println(" microsegundos");

  // Escribir la salida filtrada en el DAC, ajustando el valor si es necesario
  dac.write((uint16_t)filtered_signal + 512);
}

// Interrupción del temporizador
void Timer1_ISR(void) {
  timerDone = 1;
}

//Función para aplicar filtro
float apply_filters(float x) {
  // Filtrar la señal con el filtro seleccionado
  float y = filtrar(x, ak1, bk1, N_b1);
  return y;
}