Aplicación: Audio con PWM

Una aplicación inmediata (y más interesante que los LED de colores del programa anterior) de la modulación PWM es intentar reproducir un archivo de audio digital tipo WAV usando el módulo PWM del PIC como un DAC (Digital-Analog Converter) incorporado.

Obviamente el principal problema es dónde guarda el PIC el audio a reproducir.  En la memoria de un PIC pueden caber unos 1000/2000 bytes, lo que a un ritmo de típico de 8 o 10 KHz solo da para una fracción de segundo. Lo que vamos a hacer en esta aplicación es recibir los datos a través del puerto serie. Si ajustamos la velocidad del puerto serie a 115200, teniendo en cuenta que para cada byte necesitamos mandar 10 bits (datos + start + stop) esto se traduce a un ritmo de unos 11500 bytes/segundo, muy cercano a 11025 que es una típica frecuencia de muestreo de archivos de audio. Según lleguen los datos por el puerto serie los usaremos para modificar el ciclo de trabajo del módulo PWM que previamente habremos configurado.

A la izquierda tenemos una foto con el hardware usado. A la derecha, un video donde pueden oírse el resultado,  junto con una captura de la señal PWM en el osciloscopio:

                  

                         

Código asociado a esta entrada:  PWM_audio_serial.c
Proyecto C18 completo:  proyecto.rar

------------------------------------------------------------------------------------------------------------------------------

Hardware:

Obviamente la salida del pin PWM del micro no puede conectarse directamente a un buzzer o altavoz, por lo que será necesario usar algún tipo de driver. Para esta aplicación, un simple transistor NPN bastará.  El esquema de salida (asumiendo que usamos RC2 como salida PWM) es el siguiente:

Como "altavoz" he usado uno de esos zumbadores que vienen en los teléfonos de juguete. Dado que un buzzer no deja de ser una inductancia sería conveniente usar un diodo para reducir/suprimir el kickback de la bobina cuando el PWM caiga a cero. Como las intensidades que manejamos son pequeñas puede que no sea imprescindible y de hecho yo no lo he usado en mi montaje. La resistencia usada puede estar en el rango 1-5 K

En la foto siguiente se muestra el "montaje de audio" acoplado a la placa  EasyPic6. Negro es la masa común, rojo son 5V al colector del transistor y el cable naranja trae la señal PWM desde RC2 a la base del 2222A a través de una resistencia de 2K2.

Como vamos a usar el puerto serie, será preciso un convertidor de niveles (MAX232 o similar) entre el puerto serie del PIC y el del PC. En mi caso he usado el convertidor integrado en la placa EasyPIC.

   

Software:

El primer aspecto es decidir la frecuencia PWM a usar. Una cuestión importante es conseguir que dicha frecuencia sea lo más alta posible, para distanciarla de las frecuencias de la señal de audio a reproducir (en un rango de hasta unos 5KHz).  Sabemos que, dada la frecuencia del cristal, Fosc,  la frecuencia PWM viene dada por:

        

                        F_pwm =    F_osc / (4*PRE*(PR2+1)) 

Para un oscilador de 20 MHz sabemos que la máxima frecuencia que podemos usar manteniendo 1024 (10 bits) posibles niveles para el ciclo de trabajo es de Fosc/1024 = 19.6 KHz.

Sería interesante poder aumentar más la frecuencia. Si nos limitamos a 8 bits de resolución (muy adecuado porque trabajaremos con ficheros WAV con 8 bits/muestra = 256 niveles) podríamos multiplicar por 4 dicha frecuencia hasta llegar a 20000/256 = 78 KHz. Esta elección corresponde a un divisor previo PRE=1 y PR2=63.

Además de esta forma no tendremos que reescalar los datos de audio (entre 0 y 255). Basta asignar al ciclo de trabajo del PWM el valor recibido a través del puerto serie.

En cuanto a la recepción de datos por el puerto serie, la idea es implementarlo a través de la interrupción de recepción de forma que cada vez que se reciba un carácter se use su valor para fijar el "duty" del PWM.  De esta forma no hay que guardar los valores recibidos. La diferencia entre la frecuencia de recepción de datos (11500 bytes/sec) y la frecuencia ideal de reproducción (11025 muestras/sec) es lo suficientemente pequeña para que podamos ignorarla.

Vamos con el programa que resulta ser muy sencillo. Como siempre arrancamos con los #includes y #pragmas de siempre. Vamos a usar las funciones de C18 para inicializar el puerto serie y el módulo PWM por lo que debemos incluir los ficheros adecuados:

 #include <p18F4520.h>

#include <delays.h>

#include <timers.h>

#include <pwm.h>

#include <usart.h>

 

#pragma config OSC=HS

#pragma config PWRT = OFF, BOREN = OFF

#pragma config WDT = OFF, WDTPS = 128

#pragma config PBADEN = OFF, LVP = OFF

#include "../int_defs_C18.h"    // Defs about enabling interrupts, flags, etc.

#include "../tipos.h"

uint8 get_usart_speed(uint32 baud, uint32 Fosc, uint8* spbrg)

// baud rate 1200,2400,4800,9600,19200, ..., 115200

// Fosc = Frequency osc in KHz -> 20MHz = 20000 

// Returns 0 (USART_BRGH_LOW), 1 (USART_BRGH_HIGH), or 2 (cannot get speed requested)

// It places in spbrg the value to be used as argument spbrg in OpenUSART

 {

  uint16 FF;

  uint8 brgh;

  uint8 shift;

  Fosc=Fosc*1000; 

  baud>>=1; Fosc=Fosc/baud+1; Fosc>>=1;  // computes round(Fosc/baud)

  FF=(uint16)Fosc;

 

  if ((FF>16320)||(FF<16)) return 2;   // Baud rate too low or too high

 

  brgh = (FF>4096)? 0:1;  // Decides between BRGH=0 o BRGH=1

  shift= (brgh==1)? 3:5; 

  FF>>=shift; FF--; FF>>=1; // Computes round(FF/64 -1) or round(FF/16-1)

  *spbrg = (uint8)FF;

  return brgh;

 }

También hemos incluido la rutina get_usart_speed que usaremos para fijar la velocidad a 115200 bauds.

En cuanto a la rutina de interrupción del puerto serie es muy simple.  El inicio es simplemente un contador de bytes recibidos (cada 256 bytes incrementa PORTB). Esta parte es prescindible, ya que solo trata de dar un feedback visual de si se están recibiendo bytes a través del puerto serie.

La parte central de la ISR es simplemente coger el carácter recibido (en RCREG) y usarlo para establecer el ciclo de trabajo del PWM. Para ello colocamos sus dos bits menos significativos en CCP1CON.DC1B0 y CCP1CON.DC1B1 y los 8 más significativos (en este caso 6) en el registro CCPR1L. Ya hemos remarcado que con la configuración usada del PWM tenemos sólo 256 niveles del ciclo de trabajo, lo cual es ideal en esta aplicación porque los valores que llegan son justamente bytes:

uint8 cont=0;

// High priority interruption

#pragma interrupt high_ISR

void high_ISR (void)

{

 uint8 duty;

 if (RX_flag)

  {

   cont++; if (cont==0) PORTB++;

   duty = RCREG;

   CCP1CONbits.DC1B0=(duty& 0x01); duty>>=1;

   CCP1CONbits.DC1B1=(duty& 0x01); duty>>=1;

   CCPR1L=(duty);

   RX_flag=0;

  }

}

// Code @ 0x0008 -> Jump to ISR for high priority ints

#pragma code high_vector = 0x0008

  void high_interrupt (void){_asm goto high_ISR _endasm}

#pragma code

Como siempre que hemos pensado bien las cosas y hemos decidido que una interrupción haga el trabajo, en la rutina principal queda poco que hacer:

• Inicializar el módulo PWM (PR2=63, PRE=1  => 78 KHz, 256 niveles de resolución).
• Inicializamos el puerto serie a 115200 bauds.
• Habilitamos la interrupción de recepción del puerto serie (junto con las interrupciones globales y periféricas).
• Esperamos (while) sin hacer nada hasta que lleguen cosas por el puerto serie y la interrupción de recepción haga su trabajo.

void main()

{

 uint8 brgh,brgh_config,sp; 

 TRISB=0; PORTB=0;

 // Configure Serial POrt @ 115K

 brgh=get_usart_speed(115200,20000,&sp);

 brgh_config=(brgh)? USART_BRGH_HIGH:USART_BRGH_LOW;

 OpenUSART(USART_ASYNCH_MODE & USART_EIGHT_BIT & brgh_config, sp);

 // Configure PWM1 (RC2) @ 78 KHz with 256 levels od duty cicle

 OpenPWM1(63);   

 OpenTimer2(TIMER_INT_OFF & T2_PS_1_1); // Starts TMR2 with 1:1 prescaler

// Enable RX int, along with global and peripherical ints.

 enable_RX_int; enable_perif_ints; enable_global_ints;

 while(1);

}

Para probar el programa basta mandar (usando vuestro programa de terminal favorito) cualquier fichero WAV (configurado a 11025 Hz, 1 canal, 8 bits/sample) al puerto serie configurado a 115200 bauds.

Los resultados se muestran en el siguiente vídeo que ya vimos al principio  http://youtu.be/sRahHYadGtg

En el video vemos una captura de la pantalla del osciloscopio. El canal 1 (arriba) muestra la señal PWM a la salida del PIC. El canal 2 (abajo) muestra el voltaje en el "altavoz". El periodo de la señal es constante (unos 13 usec) y corresponde a la frecuencia PWM (78 KHz). El ciclo de trabajo cambia con los contenidos de la señal, aunque su correlación con el audio no se aprecia bien por la lenta actualización de la pantalla del osciloscopio. En el audio podemos escuchar el resultado, grabado a través de un micrófono colocado junto al altavoz.  

El resultado es bastante cutre desde el punto de vista de calidad de audio, pero ilustra bien las posibilidades de la modulación PWM como un conversor Digital/Analógico.

Se puede usar cualquier WAV a 11025, 1 canal y 8 bits (1 byte) por muestra. Al principio puede sonar un "click". Es simplemente el resultado de mandar al "altavoz" la cabecera del fichero WAV. Afortunadamente dicha cabecera es muy corta y enseguida llegan los datos de audio. Si el fichero está configurado como MONO y 8 bits/muestra entonces cada byte corresponde a una muestra y el audio se escuchará "correctamente".

Si no disponéis de un fichero WAV de las características descritas, aquí podéis descargaros un ejemplo para probar vuestro montaje: test_11025.wav.

Las posibilidades de mejora son muchas:

• Parsear los datos del fichero WAV para saltarnos la cabecera y mandar sólo el audio.
• Usar un verdadero DAC externo en lugar del módulo PWM como conversor digital/analógico.
• Usar una tarjeta de memoria como fuente de datos.

Exploraremos algunas de ellas en sucesivas aplicaciones.