procesamiento de señales digitales (DSP).

Definiciones iniciales

p = cos ɸ
q = sin ɸ
ck = cos(k · ɸ)
sk = sin(k · ɸ)
r = coeficiente de filtrado
fo = frecuencia de corte
fs = frecuencia de muestreo

Filtro pasa banda

ck+1 = r · (p · ck - q · sk) + ul
sk+1 = r · (q · ck + p · sk) Estas ecuaciones describen un filtro pasa banda recursivo. Los términos ck y sk representan las componentes coseno y seno de la señal filtrada, respectivamente. El coeficiente r controla el ancho de banda del filtro.

// Definir las variables
float p, q, ck, sk, r;
float ul; // Entrada del filtro

void setup() {
// Inicializar valores (ajusta según tus necesidades)
p = cos(0.5); // Ejemplo: ángulo de 0.5 radianes
q = sin(0.5);
ck = 0.0; // Valor inicial
sk = 0.0; // Valor inicial
r = 0.9; // Coeficiente de filtrado (ajusta según tus necesidades)
ul = 0.0; // Valor de entrada (ajusta según tus necesidades)
}

void loop() {
// Actualizar componentes ck y sk
float ck_nuevo = r * (p * ck - q * sk) + ul;
float sk_nuevo = r * (q * ck + p * sk);

// Guardar los nuevos valores
ck = ck_nuevo;
sk = sk_nuevo;

// Hacer algo con ck y sk (por ejemplo, enviarlos a otro dispositivo)
}

b1=-r^2 b2=2·r·cos(2·π·fo/fs)

#include <Arduino.h>

// Parámetros del filtro
float r = 0.9; // Coeficiente de filtrado (ajusta según tus necesidades)
float fo = 1000.0; // Frecuencia central del filtro (en Hz)
float fs = 10000.0; // Frecuencia de muestreo (en Hz)

// Variables para los coeficientes
float b1, b2;

void setup() {
// Calcular los coeficientes
float pi = 3.14159265358979323846;
float omega = 2.0 * pi * fo / fs;
b1 = -r * r;
b2 = 2.0 * r * cos(omega);

// Inicializar otras variables si es necesario
}

void loop() {
// Obtener una muestra de la señal de entrada (por ejemplo, desde un sensor analógico)
float muestraEntrada = analogRead(A0) * 5.0 / 1023.0; // Escalar a voltaje

// Filtrar la muestra
float muestraFiltrada = b1 * muestraEntrada + b2 * muestraEntrada;

// Hacer algo con la muestra filtrada (por ejemplo, enviarla a otro dispositivo)
}

Filtro pasa banda senoidal cosenoidal

ck2 = b1 · ck1 + b2 · ck + uk Donde:
b1 = -r^2
b2 = 2 · r · cos(2 · π · fo / fs)
Esta es una implementación específica de un filtro pasa banda, donde fo es la frecuencia central del filtro y fs es la frecuencia de muestreo. El término uk representa la entrada del filtro.

#include <Arduino.h>

// Parámetros del filtro
float b1, b2;
float ck1, ck, uk; // Variables para las componentes

void setup() {
// Inicializar valores (ajusta según tus necesidades)
b1 = -0.81; // Coeficiente b1
b2 = 0.9;   // Coeficiente b2
ck1 = 0.0;  // Valor inicial de ck1
ck = 0.0;   // Valor inicial de ck
uk = 0.0;   // Valor de entrada (ajusta según tus necesidades)
}

void loop() {
// Actualizar componente ck2
float ck2 = b1 * ck1 + b2 * ck + uk;

// Guardar el nuevo valor
ck1 = ck;
ck = ck2;

// Hacer algo con ck2 (por ejemplo, enviarlo a otro dispositivo)
}

Eco simple

yk = sk + a · skm Donde sk es el sonido original y skm es la señal retardada atenuada por el factor a. Esta ecuación simula un eco simple.

#include <Arduino.h>

// Parámetros del eco
float a = 0.5; // Factor de escala (ajusta según tus necesidades)
float skm = 0.0; // Valor inicial de la constante de atenuación retardada

void setup() {
// Inicializar otras variables si es necesario
}

void loop() {
// Obtener una muestra del sonido original (por ejemplo, desde un micrófono o sensor)
float sk = analogRead(A0) * 5.0 / 1023.0; // Escalar a voltaje

// Calcular el eco
float yk = sk + a * skm;

// Guardar el nuevo valor de skm para la siguiente iteración
skm = yk;

// Hacer algo con el sonido resultante (por ejemplo, reproducirlo en un altavoz)
}

Eco múltiple

yk = sk + a · skL + b · skm Esta es una extensión del eco simple, añadiendo un segundo término de eco con diferente retardo (L) y atenuación (b).

#include <Arduino.h>

// Parámetros del eco múltiple
float a = 0.5; // Factor de escala para kL
float b = 0.3; // Factor de escala para s_{km}
float kL = 0.0; // Valor inicial de kL
float skm = 0.0; // Valor inicial de s_{km}

void setup() {
// Inicializar otras variables si es necesario
}

void loop() {
// Obtener una muestra del sonido original (por ejemplo, desde un micrófono o sensor)
float sk = analogRead(A0) * 5.0 / 1023.0; // Escalar a voltaje

// Calcular el eco múltiple
float yk = sk + a * kL + b * skm;

// Actualizar los valores para la siguiente iteración
kL = yk;
skm = sk;

// Hacer algo con el sonido resultante (por ejemplo, reproducirlo en un altavoz)
}

Filtro FIR (Respuesta Impulsiva Finita)

yk = a0 · xk + a1 · xk-1 + a2 · xk-2 + ... O en notación de suma: y(n) = Σ a(k) · x(n - k) Estas ecuaciones describen un filtro FIR, donde la salida y(n) es una combinación lineal de las entradas actuales y pasadas x(n-k), ponderadas por los coeficientes a(k).

#include <Arduino.h>

// Coeficientes del filtro FIR
float a0, a1, a2;
float xk1, xk2; // Valores anteriores de la entrada

void setup() {
// Inicializar los coeficientes y otros valores si es necesario
}

void loop() {
// Obtener una muestra de la señal de entrada (por ejemplo, desde un sensor analógico)
float xk = analogRead(A0) * 5.0 / 1023.0; // Escalar a voltaje

// Calcular la salida del filtro FIR
float yk = a0 * xk + a1 * xk1 + a2 * xk2;

// Actualizar los valores anteriores para la siguiente iteración
xk2 = xk1;
xk1 = xk;

// Hacer algo con la salida filtrada (por ejemplo, enviarla a otro dispositivo)
}

#include <Arduino.h>

// Longitud del filtro FIR (ajusta según tus necesidades)
const int LEN = 10;

// Coeficientes del filtro FIR
float a[LEN] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0};
float x[LEN]; // Vector de muestras de entrada
float y = 0.0; // Salida del filtro

void setup() {
// Inicializar valores de entrada (por ejemplo, desde un sensor analógico)
for (int i = 0; i < LEN; i++) {
x[i] = analogRead(A0) * 5.0 / 1023.0; // Escalar a voltaje
}
}

void loop() {
// Calcular la salida del filtro FIR
y = 0.0;
for (int i = 0; i < LEN; i++) {
y += a[i] * x[i];
}

// Actualizar el vector de muestras de entrada (desplazando las muestras anteriores)
for (int i = LEN - 1; i > 0; i--) {
x[i] = x[i - 1];
}
x[0] = analogRead(A0) * 5.0 / 1023.0; // Nueva muestra de entrada

// Hacer algo con la salida filtrada (por ejemplo, enviarla a otro dispositivo)
}

Filtro IIR (Respuesta Impulsiva Infinita)

y(n) = Σ a(k) · x(n - k) + Σ b(k) · y(n - k) Esta ecuación describe un filtro IIR, que incluye tanto las entradas pasadas x(n-k) como las salidas pasadas y(n-k) en el cálculo de la salida actual. Los coeficientes a(k) y b(k) determinan las características del filtro. Estas fórmulas representan diferentes tipos de filtros y efectos comúnmente utilizados en DSP. Cada una tiene sus propias características y aplicaciones específicas en el procesamiento de señales de audio y otros tipos de señales digitales.

#include <Arduino.h>

// Longitud del filtro IIR (ajusta según tus necesidades)
const int LEN = 10;

// Coeficientes del filtro IIR
float a[LEN] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0};
float b[LEN] = {0.5, 0.4, 0.3, 0.2, 0.1, 0.0, -0.1, -0.2, -0.3, -0.4};
float y[LEN]; // Vector de salidas

void setup() {
// Inicializar valores de salida (por ejemplo, a 0)
for (int i = 0; i < LEN; i++) {
y[i] = 0.0;
}
}

void loop() {
// Obtener una muestra de la señal de entrada (por ejemplo, desde un sensor analógico)
float x = analogRead(A0) * 5.0 / 1023.0; // Escalar a voltaje

// Calcular la salida del filtro IIR
float yn = 0.0;
for (int k = 0; k < LEN; k++) {
yn += a[k] * x * pow(0.5, k) + b[k] * y[k];
}

// Actualizar el vector de salidas (desplazando las salidas anteriores)
for (int i = LEN - 1; i > 0; i--) {
y[i] = y[i - 1];
}
y[0] = yn;

// Hacer algo con la salida filtrada (por ejemplo, enviarla a otro dispositivo)
}

Reparaciones Marvill