Sí, se puede. Construir tu propio pedal de efectos para guitarra con Python es un proyecto realista y, además, muy didáctico. No necesitas gastar un dineral en pedales físicos ni tener conocimientos avanzados de electrónica. Con una interfaz de audio, un portátil y algunas librerías de Python, puedes tener un procesador de guitarra en tiempo real con distorsión, delay y reverberación totalmente programables.
¿Merece la pena un pedal virtual?
Los pedales físicos llevan décadas siendo la opción favorita de los guitarristas. Son robustos, fiables y tienen un tacto que muchos adoran. Pero un procesador virtual te da una flexibilidad increíble: puedes cambiar el orden de los efectos, ajustar parámetros al milímetro y experimentar sin límites. Eso sí, introduces latencia y dependes de un ordenador. Para grabar en casa, practicar o diseñar tus propios sonidos, esta opción es imbatible. Y si luego quieres convertir la grabación a MP3 para compartirla, herramientas como y-mp3.top te facilitan la conversión de formatos de audio al instante.
Lo que necesitas
- Un ordenador con Python 3.8 o superior instalado.
- Una interfaz de audio con entrada de instrumento (HI-Z) y salida de monitorización. Si usas la entrada de micrófono del PC, la latencia será mayor y el ruido, un invitado no deseado.
- Conocimientos básicos de Python (funciones, bucles, importar librerías).
- Las librerías:
sounddevice(para capturar y reproducir audio),numpy(procesamiento numérico) yscipy(para filtros y convulación). Las instalas conpip install sounddevice numpy scipy.
Paso 1: el flujo de audio en tiempo real
La base de todo es leer muestras de la guitarra, tratarlas y enviarlas a los altavoces lo más rápido posible. Con sounddevice creamos un stream con una función callback que se ejecuta cada vez que hay nuevas muestras:
import sounddevice as sd
import numpy as np
def callback(indata, outdata, frames, time, status):
# 'indata' contiene las muestras de entrada (float32, [-1,1])
# Aquí aplicaremos los efectos
outdata[:] = indata # Por ahora, pasamos la señal sin cambios
with sd.Stream(callback=callback):
print("Procesando... Presiona Ctrl+C para salir")
while True:
pass
Este bucle infinito se queda esperando y va llamando al callback constantemente. Ojo: si el callback tarda mucho, oirás saltos y chasquidos. Por eso los efectos deben ser eficientes.
Paso 2: distorsión con saturación digital
La distorsión más sencilla es un recorte (clipping): amplificamos la señal y limitamos los picos. En código:
def distortion(signal, gain, threshold=1.0):
boosted = signal * gain
return np.clip(boosted, -threshold, threshold)
Un gain de 3 o 4 ya genera un crunch agresivo. Puedes probar con saturación suave usando una función tangente, que suena más cálido. Pero el clipping duro es un buen punto de partida.
Paso 3: delay con feedback
El delay almacena las últimas muestras en una cola y las reproduce después de un tiempo. Aquí una implementación básica:
class DelayEffect:
def __init__(self, delay_seconds, feedback, samplerate):
self.buffer = np.zeros(int(delay_seconds * samplerate))
self.feedback = feedback
self.pos = 0
def process(self, signal):
out = np.zeros_like(signal)
for i, s in enumerate(signal):
delayed = self.buffer[self.pos]
out[i] = s + delayed
self.buffer[self.pos] = s + delayed * self.feedback
self.pos = (self.pos + 1) % len(self.buffer)
return out
El parámetro feedback controla cuántas repeticiones, entre 0.0 y casi 1.0. Con 0.5 obtienes un eco agradable; con 0.9, un muro de repeticiones hipnótico.
Paso 4: reverberación con filtro de Schroeder
Una reverb realista es compleja, pero podemos simular un ambiente pequeño combinando varios retardos de distinta duración y realimentación negativa. Esta es la idea de los filtros de Schroeder. Para no liarnos, usaremos una cascada de cuatro de estos filtros:
from scipy.signal import lfilter
def schroeder_reverb(signal, delays_ms, gains, samplerate):
delays = [int(d * samplerate / 1000) for d in delays_ms]
for delay, g in zip(delays, gains):
# Filtro todo-paso con realimentación
a = [1] + [0]*(delay) + [g]
b = [g] + [0]*(delay) + [1]
signal = lfilter(b, a, signal)
return signal
Con tiempos de 30, 40, 50 y 60 ms y ganancias alrededor de 0.7, se consigue una reverberación aceptable. El resultado no compite con una convolución de impulso real, pero gasta muy poca CPU.
Paso 5: integrarlo todo en el callback
Ahora tienes que combinar los tres efectos. El orden clásico es: distorsión → delay → reverb. Dentro del callback, antes de copiar a outdata, procesas la señal:
delay = DelayEffect(delay_seconds=0.3, feedback=0.4, samplerate=self.samplerate)
def callback(indata, outdata, frames, time, status):
signal = indata[:, 0] # Mono, canal izquierdo
# Distorsión
signal = distortion(signal, gain=3.5)
# Delay
signal = delay.process(signal)
# Reverb (ajusta ganancias)
signal = schroeder_reverb(signal, [30,40,50,60], [0.6,0.6,0.6,0.6], self.samplerate)
# Normalizar para evitar saturaciones
signal /= np.max(np.abs(signal))
outdata[:, 0] = signal
outdata[:, 1] = signal # Copiamos a estéreo
Ya está. Ajusta los parámetros a tu gusto y tendrás un sonido bastante convincente.
Consejos para reducir la latencia
La latencia es el peor enemigo del guitarrista virtual. Aquí van unos trucos:
- Usa un tamaño de bloque pequeño (64 o 128 muestras) en la configuración de
sounddevice. A costa de más CPU. - Evita bucles Python en los efectos: usa funciones vectorizadas de numpy siempre que puedas.
- Si tu máquina va justa, quita la reverb o simplifícala.
- En sistemas de audio profesionales, instala ASIO (Windows) o JACK (Linux) para conseguir latencias inferiores a 10 ms.
Preguntas frecuentes
¿Puedo controlar los parámetros con un controlador MIDI?
Sí, con la librería mido puedes leer mensajes MIDI y mapearlos a los valores de ganancia, tiempos, etc. Es un proyecto estupendo para llevar tu pedal al siguiente nivel.
¿Funciona con bajo eléctrico?
Exactamente igual. Solo necesitas ajustar los rangos de ganancia y ecualización si quieres preservar las frecuencias graves. La distorsión puede emborronar los graves, así que muchos bajistas dividen la señal (clean blend).
¿Cómo grabo la salida para luego usarla?
Puedes guardar el array de outdata en un archivo WAV con scipy.io.wavfile.write. Si necesitas convertirlo a MP3, un conversor en línea como y-mp3.top te simplifica el proceso.
¿Merece la pena frente a soluciones como Guitar Rig o Amplitube?
En calidad de sonido, esos programas están a otro nivel. Pero este proyecto te da control absoluto y te ayuda a entender el procesamiento de audio desde cero. Es aprendizaje puro.
