Informe - Escuela de Ingeniería Eléctrica
Anuncio
Universidad de Costa Rica
Facultad de Ingeniería
Escuela de Ingeniería Eléctrica
IE – 0502 Proyecto Eléctrico
Diseño de prácticas de procesamiento digital de
señales usando SCILAB y SCICOS.
Por:
Arthur Chavarría Pérez
Ciudad Universitaria Rodrigo Facio
Julio del 2009
Diseño de prácticas de procesamiento digital de señales usando SCILAB y
SCICOS.
Por:
Arthur Chavarría Pérez
Sometido a la Escuela de Ingeniería Eléctrica
de la Facultad de Ingeniería
de la Universidad de Costa Rica
como requisito parcial para optar por el grado de:
BACHILLER EN INGENIERÍA ELÉCTRICA
Aprobado por el Tribunal:
_________________________________
Ph.D. Jorge Romero Chacón
Profesor Guía
_________________________________
Ing. Rodrigo Chacón Quesada
Profesor lector
_________________________________
Ing. Claudio Umaña Valverde
Profesor lector
ii
DEDICATORIA
Dedico este proyecto a mis padres, hermanos, otros familiares y
amigos quienes siempre han estado cerca de mí y me han
apoyado en todo momento.
iii
ÍNDICE GENERAL
ÍNDICE DE FIGURAS..................................................................................vii
ÍNDICE DE TABLAS......................................................................................x
NOMENCLATURA........................................................................................xi
RESUMEN......................................................................................................xii
CAPÍTULO 1: Introducción...........................................................................1
1.1 Objetivos..........................................................................................................................................................3
1.1.1 Objetivo general.................................................................................................................................3
1.1.2 Objetivos específicos.........................................................................................................................3
1.2 Metodología....................................................................................................................................................4
CAPÍTULO 2: Desarrollo teórico...................................................................5
2.1 Introducción a SCILAB..................................................................................................................................5
2.2 SCILAB y el procesamiento de señales..........................................................................................................6
2.2.1 Tratamiento de señales.......................................................................................................................7
a) Representación de un sistema lineal por su función de transferencia.....................................................7
b) Representación en el espacio de estados (EE) de un sistema lineal.......................................................8
c) Cambio de representación: paso de función de transferencia (FT) al Espacio de Estados (EE) y
viceversa......................................................................................................................................................9
d) Discretización de sistemas continuos.....................................................................................................9
e) Filtrado y su representación gráfica......................................................................................................11
f) La FFT (Transformada rápida de Fourier) y la DFT (Transformada de Fourier discreta)....................13
g) Convolución..........................................................................................................................................15
h) Chirp Z-transform (CZT). ....................................................................................................................16
2.2.2 Diseño de filtros con SCILAB........................................................................................................18
a) Diseño de filtros FIR (Finite Impulse Response).................................................................................18
b) Técnicas de muestreo de frecuencia.....................................................................................................21
2.2.3 Manipulación de sonido en SCILAB...............................................................................................25
2.2.4 Gráficas............................................................................................................................................26
2.3 SCICOS.........................................................................................................................................................28
2.3.1 El editor de SCICOS.......................................................................................................................31
2.3.2 Construcción de un modelo en SCICOS.........................................................................................31
2.3.3 Tipos de bloques en SCICOS..........................................................................................................36
a) Bloque normal simple continuo. ..........................................................................................................37
b) Bloque normal simple discreto. ...........................................................................................................39
c) Bloque simple de cruce por cero...........................................................................................................40
d) Bloque simple sincronizado..................................................................................................................41
e) Herencia y dependencia temporal ........................................................................................................42
2.3.4 Construcción de nuevos bloques.....................................................................................................42
iv
2.3.5 Definición de la estructura de datos del bloque. ............................................................................45
2.3.6 Función computacional...................................................................................................................48
a) Tipos de funciones computacionales....................................................................................................51
CAPÍTULO 3: Elaboración de prácticas de procesamiento digital de
señales en SCILAB.........................................................................................53
3.1 Primera práctica.............................................................................................................................................53
3.1.1 Resultados para la primera práctica:. ..............................................................................................59
a) Resultados del programa 1.1.................................................................................................................59
b) Resultados del programa 1.2.................................................................................................................61
c) Resultados del programa 1.3.................................................................................................................62
d) Resultados del programa 1.4.................................................................................................................64
3.2 Segunda práctica...........................................................................................................................................66
3.2.1 Resultados de la segunda práctica. ….............................................................................................72
a) Resultados del programas 2.1...............................................................................................................72
b) Resultados del programa 2.2.................................................................................................................73
c) Resultados del programa 2.3.................................................................................................................74
d) Resultados del programa 2.4 ................................................................................................................76
3.3 Tercera práctica............................................................................................................................................78
3.3.1 Resultados de la tercera práctica......................................................................................................88
a) Resultados del programa 3.1.................................................................................................................88
b) Resultados del programa 3.2.................................................................................................................89
c) Resultados del programa 3.3.................................................................................................................91
d) Resultados del programa 3.4.................................................................................................................93
e) Resultados del programa 3.5.................................................................................................................94
3.4 Cuarta práctica..............................................................................................................................................95
3.4,1 Resultados de la cuarta práctica....................................................................................................105
a) Resultados del programa 4.1...............................................................................................................105
b) Resultados del programa 4.2...............................................................................................................107
c) Resultados del programa 4.3...............................................................................................................107
d) Resultados del programa 4.4...............................................................................................................108
e) Resultados del programa 4.5 ..............................................................................................................108
f) Resultados del programa 4.6 ..............................................................................................................108
3.5 Quinta práctica ….......................................................................................................................................109
3.5.1 Resultados de la quinta práctica.....................................................................................................119
a) Resultados de la parte A.....................................................................................................................119
b) Resultados de la parte B....................................................................................................................123
c) Resultados de la parte C......................................................................................................................124
3.6 Sexta práctica..............................................................................................................................................126
3.6.1 Resultados de la sexta práctica.......................................................................................................138
a) Resultados de la parte A.....................................................................................................................138
3.7 Séptima práctica............................................................................................................................................143
3.7.1 Código MATLAB de la práctica 7.................................................................................................155
3.7.2 Resultados de la séptima práctica..................................................................................................161
CAPÍTULO 4: Elaboración de prácticas de procesamiento digital de
señales en SCICOS.......................................................................................163
4.1 Primera práctica..........................................................................................................................................163
4.1.1 Solución a la primera práctica en SCICOS. ….............................................................................174
4.2 Segunda práctica.........................................................................................................................................177
v
4.2.1 Resultados de la segunda práctica.................................................................................................185
4.3 Tercera práctica en SCICOS.....................................................................................................................190
BIBLIOGRAFÍA..........................................................................................200
vi
ÍNDICE DE FIGURAS
Índice del usuario
Figura 2.1 Señal de salida del filtro yhz.............................................................................................................12
Figura 2.2 Señal de entrada X del filtro..............................................................................................................13
Figura 2.3 Función coseno sin filtrar..................................................................................................................14
Figura 2.4 Transformada discreta de Fourier de la señal coseno.......................................................................15
Figura 2.4 Transformada discreta de Fourier de la señal coseno.......................................................................15
Figura 2.5 Localización de las muestras de la transformada Z para Wo < 1 y Wo > 1. ....................................17
Figura 2.5 Localización de las muestras de la transformada Z para Wo < 1 y Wo > 1. ....................................17
Figura 2.6 Filtro pasa banda tipo 1 sin muestra y con muestra en cada banda de transmisión. .......................23
Figura 2.7 Filtro paso bajo tipo 1 y tipo 2. ........................................................................................................24
Figura 2.8 Filtro paso bajo tipo 1 y tipo 2. ........................................................................................................29
Figura 2.8 Filtro paso bajo tipo 1 y tipo 2. ........................................................................................................29
Figura 2.9 Estructura de los bloques en SCICOS. .............................................................................................30
Figura 2.10 Ventana principal de SCICOS. ......................................................................................................31
Figura 2.11 Ventana de elección de paletas. .....................................................................................................32
Figura 2.12 Ventana de ayuda a través de SCILAB. .........................................................................................35
Figura 2.13 Cuadro de diálogo de selección de demos. ....................................................................................35
Figura 2.14 Apariencia de un super bloque. ......................................................................................................36
Figura 2.15 Bloque normal simple continuo. ....................................................................................................38
Figura 2.16 Bloque normal simple discreto. ......................................................................................................40
Figura 2.17 Bloque simple de cruce por cero. . .................................................................................................41
Figura 2.18 Bloque simple sincronizado. ..........................................................................................................42
Figura 3.1 Parte real de la secuencia exponencial compleja realizada en MATLAB........................................59
Figura 3.2 Parte imaginaria de la secuencia exponencial compleja realizada en MATLAB.............................60
Figura 3.3: Parte real de la secuencia exponencial compleja realizada en SCILAB..........................................60
Figura 3.4 Parte imaginaria de la secuencia exponencial compleja realizada en SCILAB................................61
Figura 3.5 Generación de secuencia exponencial real con a = 1.2, K = 0.2 y N = 30 en SCILAB....................61
Figura 3.6 Generación de secuencia exponencial real con a = 0.9, K = 20 y N = 30 en SCILAB....................61
Figura 3.7 Generación de secuencia exponencial real con a = 1.2, K = 0.2 y N = 30 en MATLAB.................62
Figura 3.8 Generación de secuencia exponencial real con a = 0.9, K = 20 y N = 30 en MATLAB.................62
Figura 3.9 Señal original no corrompida y señal de ruido generadas con MATLAB........................................63
Figura 3.10 Señal original no corrompida y señal de ruido generadas con SCILAB.........................................63
Figura 3.11 Señales de entrada y señal sin suavizar en SCILAB.......................................................................64
Figura 3.12 Señal original y señal suavizada obtenida con SCILAB.................................................................64
Figura 3.13 Señales de entrada y señal sin suavizar en MATLAB....................................................................65
Figura 3.14 Señal original y señal suavizada obtenida con MATLAB..............................................................65
Figura 3.15 Ilustración de convolución en SCILAB..........................................................................................73
Figura 3.16 Ilustración de convolución en MATLAB.......................................................................................73
Figura 3.17 Ilustración del cálculo de la respuesta al impulso en SCILAB.......................................................74
Figura 3.18 Ilustración del cálculo de la respuesta al impulso en MATLAB....................................................74
Figura 3.19 Cálculo de la secuencia de correlación cruzada en SCILAB..........................................................75
Figura 3.20 Cálculo de la secuencia de correlación cruzada en MATLAB.......................................................75
Figura 3.21 Cálculo de la autocorrelación de una secuencia sinusoidal corrompida por ruido usando SCILAB.
............................................................................................................................................................................76
Figura 3.22 Cálculo de la autocorrelación de rdd usando SCILAB...................................................................76
vii
Figura 3.23 Cálculo de la autocorrelación de una secuencia sinusoidal corrompida por ruido usando
MATLAB...........................................................................................................................................................77
Figura 3.24 Cálculo de la autocorrelación de rdd usando MATLAB................................................................77
Figura 3.25 Calculo de la DFT en MATLAB....................................................................................................88
Figura 3.27 Secuencia temporal original en SCILAB........................................................................................89
Figura 3.28 Magnitud de las muestras de la DFT y fase de las muestras de la DFT en SCILAB....................89
Figura 3.29 Secuencia temporal original en MATLAB.....................................................................................90
Figura 3.30 Magnitud de las muestras de la DFT y fase de las muestras de la DFT en MATLAB..................90
Figura 3.31 Muestras originales DFT en SCILAB.............................................................................................91
Figura 3.32 Parte real de las muestras temporales y parte real de las muestras temporales en SCILAB..........91
Figura 3.33 Muestras originales DFT en MATLAB..........................................................................................92
Figura 3.34 Parte real de las muestras temporales y parte real de las muestras temporales en MATLAB.......92
Figura 3.35 Gráfica de la respuesta en frecuencia en SCILAB..........................................................................93
Figura 3.36 Gráfica de la respuesta en frecuencia en MATLAB.......................................................................93
Figura 3.37 Convolución lineal por medio de la DFT en SCILAB....................................................................94
Figura 3.38 Polos y ceros en el plano Z obtenidos en MATLAB....................................................................106
Figura 3.39 Polos y ceros en el plano Z obtenidos en SCILAB.......................................................................107
Figura 3.40 Tren de pulsos en MATLAB y SCILAB......................................................................................119
Figura 3.41 Espectro correspondiente sobre el intervalo de Nyquist normalizado (-1,1) en MATLAB y
SCILAB............................................................................................................................................................120
Figura 3.42 Señal coseno con ocho muestras por ciclo multiplicándola (elemento por elemento) por el tren de
impulsos............................................................................................................................................................120
Figura 3.43 Respuesta al impulso efectiva y su respuesta de magnitud en MATLAB y SCILAB.................121
Figura 3.44 Señal en el dominio del tiempo obtenida con MATLAB y SCILAB...........................................121
Figura 3.45 Señal en el dominio de la frecuencia obtenida con MATLAB y SCILAB...................................122
Figura 3.46 Señales para aplicar un postfiltro en MATLAB y SCILAB.........................................................122
Figura 3.47 Respuesta en el tiempo al aplicar FFT en MATLAB y SCILAB.................................................123
Figura 3.48 Primer ejemplo de aliasing en MATLAB y SCILAB. .................................................................123
Figura 3.49 Respuesta de FFT MATLAB y SCILAB. ....................................................................................124
Figura 3.50 Secuencia exponencial causal en MATLAB y SCILAB..............................................................124
Figura 3.51 Espectro de frecuencia y señal original en MATLAB y SCILAB................................................124
Figura 3.52 Interpolación de un senoide por L = 4.........................................................................................125
Figura 3.53 Despliegue en el dominio de la frecuencia del error en MATLAB y SCILAB..........................125
Figura 3.54 Chequeo de decimación en MATLAB y SCILAB.......................................................................125
Figura 3.55 Efectos de la convolución circular................................................................................................138
Figura 3.56 Convolución circular y rellenos con ceros....................................................................................139
Figura 4.1 a) Diagrama de polos y ceros y b) respuesta en frecuencia de un resonador. …............................165
Figura 4.2 Diagrama de sistema para realizar filtrado con un filtro resonante digital….......................……...167
Figura 4.3 (a) Comportamiento del filtro Notch ideal y (b) comportamiento real del filtro Notch.................169
Figura 4.4 Respuesta en frecuencia del filtro.........................……………………….......................………....170
Figura 4.5 Sistema de prueba de filtro Notch………………………………………………............................171
Figura 4.6 Filtro digital de orden 3………………………………………………………….......................….172
Figura 4.7 Respuesta en frecuencia de un filtro paso bajo…………………………………............................173
Figura 4.8 Aplicación para filtro paso bajo…………………………………………….......................……....174
Figura 4.9 Señal de salida “Gráfico 1” y señal de entrada “Gráfico 2”……………………............................175
Figura 4.10 Señal de entrada “Grafico 1” y señal muestreada “Gráfico 2”. Filtro paso
banda resonante digital………………………………………………………………….......................……...175
Figura 4.11 Señal de entrada muestreada y sin muestrear……………………………………........................176
Figura 4.12 Señal filtrada por ambos filtros (Gráfico 1) y señal filtrada por el filtro Notch (Gráfico 2).........176
Figura 4.13 Señal de entrada y salida filtro paso bajo en diagrama de bloques…….......................………….177
viii
Figura 4.14 Señal de entrada y salida de filtro paso bajo con el bloque de función de
transferencia......................................................................................................................................................177
Figura 4.15 Ejemplo de un banco de filtros sencillo. …..................................................................................178
Figura 4.16 Diagrama de un banco de filtro simple………………………………………….........................179
Figura 4.17 Banco de filtros análisis-síntesis. ….............................................................................................182
Figura 4.18 Aplicación de un filtro de reconstrucción perfecta.......................................................................183
Figura 4.19 Diagrama de banco QMF. ….....................……………………………………......................….184
Figura 4.20 Diagrama en SCICOS de simulación de un banco de filtros QMF...............................................185
Figura 4.21 Entrada y salida de diagrama de bloques de un banco de filtros simple………….......................186
Figura 4.22 Diagrama en Simulink del primer ejemplo para la práctica 1 de SCICOS...................................187
Figura 4.23 Resultados de primer diagrama hechos con MATLAB................................................................187
Figura 4.24 Salida y entrada del banco de filtros análisis-síntesis en MATLAB…………......................…..188
Figura 4.25 Diagrama para filtro análisis-síntesis en MATLAB…………………………......................…...188
Figura 4.26 Entrada y salida de banco de filtro análisis-síntesis en SCILAB…………….......................…...189
Figura 4.27 El gráfico superior muestra la salida del filtro F0, la figura inferior muestra la salida del filtro
F1......................................................................................................................................................................189
Figura 4.28 El gráfico superior muestra la salida del sistema, el gráfico inferior es la entrada.......................190
Figura 4.29 Respuesta en frecuencia de filtro FIR de orden 30 y de un IIR de orden 6..................................192
Figura 4.30 Implementación de un filtro IIR paso banda…………………………………….........................193
Figura 4.31 Filtro FIR.......................................................................................................................................193
Figura 4.32 Sistema de filtrado analógico y digital..........................................................................................196
Figura 4.33 Salida de señal filtrada con filtro IIR............................................................................................197
Figura 4.34 Señal de entrada y de salida para filtro FIR…………………………………......................…....199
Figura 4.35 Filtro analógico y filtro digital IIR................................................................................................199
ix
ÍNDICE DE TABLAS
Tabla 2.1 Status de la función computacional................................................................................... 44
Tabla 2.2 Tipos de función................................................................................................................. 46
Tabla 2.3 Parametros de entrada/salida que utilizan funciones tipo 1.................................................47
x
NOMENCLATURA
SCICOS: SCILAB Connected Object Simulator.
INRIA: Institut National de Recherche en Informatique et Automatique
ENPC: Ecole Nationale de Ponts et Chaussées
MATLAB: Matrix Laboratory
FFT: Fast Fourier Transform
DFT: Discrete Fourier Transform
EE: Espacio de Estados
FT: Función de Transferencia
xi
RESUMEN
Este documento se enfoca en el desarrollo de prácticas para el curso de
procedimiento digital de señales de la Escuela de Ingeniería Eléctrica de la Universidad de
Costa Rica, utilizando el software libre SCILAB y su herramienta SCICOS. En total se
desarrollaron diez prácticas, de las cuales siete corresponden a prácticas elaboradas en
SCILAB y tres en SCICOS. Entre los temas desarrollados podemos encontrar prácticas
sobre la convolución de señales, transformada rápida de Fourier, transformada discreta de
Fourier, filtros digitales, bancos de filtros, muestreo, etc.
Como parte de la teoría, el segundo capítulo contempla generalidades sobre el uso de
comandos y funciones en SCILAB y SCICOS, podemos encontrar además algunos
conceptos básicos, y ejemplos del uso del software en estudio.
El tercer capítulo se refiere a las prácticas generadas o modificadas para ser
realizadas en SCILAB, además de las prácticas en este capítulo se encuentran las
soluciones de los ejercicios elaborados en SCILAB y MATLAB.
En el cuarto capítulo se encuentran las prácticas realizables en SCICOS, así como la
soluciones de los ejercicios. Las conclusiones y recomendaciones se encuentran en el
quinto capítulo.
Tanto SCILAB como SCICOS son herramientas de gran importancia para el estudio de muchos
estudiantes. A pesar de no ser tan atractivos como MATLAB y Simulink, SCILAB y SCICOS permiten
desarrollar prácticas de un elevado nivel académico y complejidad, semejantes a las elaboradas en MATLAB
y Simulink.
xii
CAPÍTULO 1: Introducción
El Internet ha cambiado en mucho la educación, permitiendo el rápido acceso a la
información y lo que es más importante el acceso libre a esta. El Internet es por lo tanto un
vasto y rico depósito de recursos computacionales. El software libre o abierto es en si, una
de las más importantes herramientas que los estudiantes pueden adquirir en Internet, siendo
una buena alternativa para elaborar aplicaciones y prácticas de ingeniería y otras
disciplinas.
Hoy en día los paquetes de software didácticos y de simulación tales como
MATLAB y su herramienta Simulink de The Mathworks, Inc., permiten gran variedad de
aplicaciones en el aprendizaje del procesamiento digital de señales, control automático, etc.
Sin embargo, dichos programas poseen licencias que son de difícil acceso y costosas para
los estudiantes, centros de aprendizaje y profesores. Ante esta situación en 1990, INRIA y
ENPC desarrollaron SCILAB y su herramienta para la simulación de sistemas dinámicos
SCICOS, programas de distribución gratuita, los cuales son las contrapartes de MATLAB y
Simulink; tales programas pueden ser muy similares en cuanto a funciones se refiere,
permitiendo el análisis de señales y otras aplicaciones. Al ser programas de distribución
gratuita, cualquier persona con conocimientos básicos de informática, podría descargar
SCILAB en Internet, lo cual, no se puede hacer con programas como MATLAB u otros
con licencias poco accesibles y costosas.
SCILAB y SCICOS dan al estudiante y profesor un complejo mundo de opciones en
cuanto a diseño y estudio de prácticas de diversas áreas, en nuestro caso SCILAB y
1
2
SCICOS permiten desarrollar prácticas de procesamiento digital de señales de igual
complejidad que las realizadas en MATLAB y Simulink.
Ante la notable necesidad de un cambio, para el acceso educativo y lograr que el
estudiante pueda obtener con facilidad las herramientas computacionales necesarias, surge
la tendencia a la utilización de programas de distribución gratuita.
SCILAB al igual que MATLAB poseen diversos comandos y funciones para el
tratamiento de señales, lo cual garantiza la posibilidad de generar y probar prácticas para el
procesamiento digital de señales. El simulador de objetos conectados de SCILAB
(SCICOS), garantiza el modelado de sistemas dinámicos que incluyen subsistemas tanto
continuos como discretos, de esta forma es posible tomar prácticas realizadas en Simulink y
llevarlas a cabo con SCICOS. Estas prácticas se deben modificar para poder amoldarlas a
SCICOS debido a ciertas variaciones existentes en la herramienta. En forma similar las
prácticas de MATLAB se deben modificar, si se desean emplear con SCILAB.
Como estudiantes o profesionales es importante el conocer la existencia de ambos
paquetes de software. Tanto MATLAB como SCILAB pueden ser muy funcionales y sus
herramientas de gran ayuda en el aprendizaje y resolución de problemas. A pesar de la
similitud existen muchas diferencias entre estos programas y en esto radica la importancia
de conocer dichas similitudes y diferencias entre ambos, con la finalidad de ser capaces de
utilizar ambos paquetes o de sustituir el programa de uso actual si es deseado.
3
1.1
1.1.1
Objetivos
Objetivo general
Diseñar, documentar y probar prácticas para la introducción del procesamiento digital
de señales utilizando el lenguaje SCILAB y su contraparte la herramienta de simulación de
procesos SCICOS.
1.1.2
Objetivos específicos
1.Diseñar y documentar prácticas de procesamiento digital de señales, a partir de los
conocimientos básicos de la disciplina.
2.Diseñar y documentar prácticas de simulación de procesos representativos del
procesamiento digital de señales con la herramienta SCICOS.
3.Realizar una comparación tanto cualitativa como cuantitativa, con MATLAB y
Simulink.
4
1.2
Metodología
1º Recopilación de información bibliográfica referente a SCILAB, SCICOS, MATLAB y
Simulink. Además de información sobre comandos y funciones de estos programas en
cuanto a procesamiento digital de señales se refiere.
2º Recopilación de prácticas de procesamiento digital de señales llevadas a cabo tanto en
MATLAB y Simulink, como en SCILAB y SCICOS.
3º Análisis, interpretación y sistematización de la información recopilada.
4º Elaboración de prácticas de procesamiento digital de señales en SCILAB y SCICOS,
basadas en las prácticas obtenidas con MATLAB y Simulink.
5º Hacer una comparación cualitativa y cuantitativa entre MATLAB y Simulink con
SCILAB y SCICOS.
6º Presentación oral del proyecto ante el tribunal calificador del mismo.
5
CAPÍTULO 2: Desarrollo teórico
Tanto SCILAB como SCICOS al ser paquetes de software matemático poseen un
amplio número de comandos y funciones que les permite generar gráficos, señales de
sonido, diagramas, entre otros. Esto implica que es importante conocer los comandos con
los cuales no estamos familiarizados así como las funciones a utilizar en las prácticas. Sin
embargo debido al gran número de funciones de SCILAB y SCICOS nos centraremos
solamente en aquellas que permiten el procesamiento de señales y generación de bloques
en SCICOS.
2.1 Introducción a SCILAB
SCILAB es un software gratuito de lenguaje de programación de alto nivel
desarrollado por INRIA y ENPC. Ha sido generado para realizar aplicaciones de sistemas
de control y aplicaciones de procesamiento de señales. En si SCILAB posee tres grandes
partes: un intérprete, una librería de funciones y librerías de rutinas Fortran y C. Entre
algunas de la aplicaciones de SCILAB tenemos fundamentos de manejo de matrices,
herramientas de álgebra lineal, herramientas de control clásico, herramientas de control
robusto, herramientas de modelos ARMA, manejo de polinomios, gráficos 2D y 3D,
herramientas de procesamiento de señales, etc.
SCILAB provee un entorno de programación robusto, en el cual podemos escribir
programas llamados scripts u objetos que podemos ejecutar.
6
Al ser un programa gratuito, SCILAB se ha desarrollado en diversos sistemas
operativos como por ejemplo LINUX y WINDOWS, logrando alcanzar a todo aquel que
desee utilizar este software.
2.2 SCILAB y el procesamiento de señales.
Entre las funciones para el tratamiento de señales, SCILAB posee una gran variedad
de funciones, como por ejemplo la convolución, la inversión de matrices, transformada
rápida de Fourier (FFT), transformada discreta de Fourier (DFT), etc.
Las herramientas encontradas en SCILAB permiten el análisis e implementación de
filtros digitales, incluyendo respuesta en frecuencia, retardo de grupo y retardo de fase.
Además la implementación de filtros puede ser directa como utilizando técnicas en el
dominio de la frecuencia basadas en la FFT. También se establece el diseño de filtros IIR,
incluyendo Butterworth, Chebyshev I, Chebyshev II, Elíptico, optimizado en su diseño con
el criterio mínimo Lp. Otras propiedades de SCILAB son el diseño de filtros FIR y su
optimizado, el procesamiento de la FFT incluyendo la transformada base-2 y su inversa, y
las transformadas para potencias que no sean de dos, estimación espectral (espectro de
potencia), filtro óptimo y suavizado (filtro de Kalman, filtro de raíz cuadrada de Kalman,
transformación de Householder, filtro de Wiener, etc).
7
2.2.1 Tratamiento de señales.
En SCILAB es posible llevar a cabo distintas funciones que permiten desde la
convolución hasta la representación de sistemas lineales a través de su función de
transferencia o su espacio de estados.
Entre algunas de las funciones generadoras de señales SCILAB posee las siguientes:
•
sin: genera la función seno de un vector o matriz.
•
cos: genera la función seno de un vector o matriz.
•
asin y acos: genera la función seno inversa y coseno inversa de un vector o
matriz.
•
exp: obtiene los exponenciales de un vector o matriz.
•
sqrt: da la raíz cuadrada de un vector o matriz.
Existen otras funciones que desarrollan otras tareas como:
•
disp: despliega variables en la pantalla.
•
Title: despliega un título en una ventana de gráfico.
Debido al gran número de funciones que posee SCILAB solo veremos las más
importantes funciones y aplicaciones en el procesamiento de señales, las cuales se muestran
a continuación.
a) Representación de un sistema lineal por su función de transferencia.
El poder representar un sistema lineal por su función de transferencia nos permite
tomar distintas decisiones sobre el comportamiento de dicho sistema así como la
posibilidad de modificar este agregando filtros u otros modificadores al sistema. En
8
SCILAB se utilizan las expresiones racionales polinómicas para describir funciones de
transferencia. Estas funciones de transferencia pueden representar señales en el dominio
temporal continuo o discreto. Pero como ya sabemos las señales son sistemas continuos que
pueden ser transformados en discretos mediante el muestreo.
Para describir la función de transferencia en SCILAB se utiliza el comando syslin
el cual presenta la siguiente sintaxis.
-->sl=syslin(dominio, numerador,denominador);
En la sintaxis anterior se define el dominio de la función de transferencia, el
numerador de la función de transferencia y el denominador de la misma.
b) Representación en el espacio de estados (EE) de un sistema lineal.
Existen dos tipos de representaciones clásicas en el Espacio de Estados, la continua
y la discreta.
La continua es como se muestra a continuación:
˙ Ax tBu t
ẋ=
(2.2-1)
yt =Cx t Du t
(2.2-2)
x 0=x o
(2.2-3)
En la forma discreta tenemos:
x n1=Ax n Bu n
(2.2-4)
yn=Cx nDu n
(2.2-5)
x 0=x o
(2.2-6)
9
Siendo A, B, C y D matrices y Xo un vector.
Para representar en el Espacio de Estados, SCILAB vuelve a utilizar la función
syslin, pero de la siguiente forma:
--> sl=syslin(dominio,a,b,c,[,d[,x0]])
Siendo el valor de retorno de sl una lista con los siguientes elementos:
-->S=list(‘lss’,a,b,c,d,x0,dominio)
c) Cambio de representación: paso de función de transferencia (FT) al Espacio de
Estados (EE) y viceversa.
En los problemas normales de tratamiento de señales nos puede interesar una u otra
representación, que son totalmente equivalentes.
Para pasar de la función de transferencia a espacio de estados se usa el comando tf2ss
cuya sintaxis es:
-->sl=tf2ss(h)
Donde sl es el espacio de estados esperado y h es la función de transferencia a
transformar.
Para pasar de espacio de estados a función de transferencia se usa el comando ss2ft
que muestra la sintaxis:
-->h=ss2ft (sl)
10
d) Discretización de sistemas continuos.
En SCILAB un sistema lineal continuo en el tiempo representado por su EE o su
FT, puede ser convertido en discreto dentro del mismo dominio temporal, esto por medio
de la función dscr:
Considérese un sistema de espacios de estados de la forma
{
C ẋ t = Ax tBu t
y t =Cx t Du t
}
(2.2-7)
De la fórmula de variación de constantes es posible estimar el valor del estado x(t)
en cualquier instante de tiempo t:
x t=e x 0 ∫ e
At
At−
Bu d
(2.2-8)
0
Sea “i” los pasos de tiempo del muestreo de la señal continúa. La entrada u se
mantiene constante en los intervalos de longitud “i”, luego el modelo discreto (D) obtenido
del anterior (C) será:
{
D x n1= Ai x nBi u n
y n=C i x nDi u n
Ai =exp Ai
}
(2.2-9)
(2.2-10)
i
Bi =∫ e A i− B d
(2.2-11)
0
La sintaxis de la función dscr es:
C i=C
(2.2-12)
D i =D
(2.2-13)
11
-->[f,g[,r]]=dscr(a,b,dt[,m])
En donde a y b son matrices asociadas al espacio de estados continuo, mientras que
f y g las matrices resultantes para el espacio de estados discreto.
x n1=Fx nCu n
(2.2-14)
Si el argumento de entrada en la función dscr fuera el espacio de estados continuo
como una lista sl, sería:
-->[sld[,r]]=dscr(sl,dt[,m])
Siendo sld la lista que se representa en el espacio de estado discreto.
En el caso en que el espacio de estados continúo esté representado por su función de
transferencia h, esta será el argumento de entrada de la función hd (FT del discreto):
-->[hd]=dscr(h,dt)
e) Filtrado y su representación grafica.
El filtrado de señales mediante filtros representados por su espacio de estados o por
su función de transferencia se realiza con la función flts la cual tiene dos formatos:
En el caso de un sistema lineal dado por la ecuación de estados la sintaxis es:
-->[y[,x]]=flts(u,sl[,0])
Cuando el sistema lineal está dado por su función de transferencia:
-->y=flts(u,h[,past])
SCILAB utiliza el comando plot para representar gráficamente cualquier señal.
12
Ahora veremos un ejemplo del uso de los comandos plot y flts. Para ello
generamos dos señales sinusoidales X1 y X2, luego definimos un filtro de respuesta
impulsional finita wfir (el cual aun no ha sido visto), sumamos las dos señales de entrada
cuyo resultado es la señal x, obtenemos la función de transferencia del filtro la cual
llamaremos hz, aplicamos el filtro a la señal x y obtenemos la salida yhz:
-->[h,hm,fr]=wfir('lp',33,[.2 0],'hm',[0 0]);
-->t=1:200;
-->x1=sin(2*%pi*t/20);
-->x2=sin(2*%pi*t/3);
-->x=x1+x2;
-->z=poly(0,'z');
-->hz=syslin('d',poly(h,'z','c')./z**33);
-->yhz=flts(x,hz);
-->plot(yhz)
La señal de salida del filtro yhz es la mostrada en la siguiente figura:
Figura 2.1 Señal de salida del filtro yhz.
13
La señal de entrada X del filtro se muestra en la siguiente figura:
Figura 2.2 Señal de entrada X del filtro.
f) La FFT (Transformada rápida de Fourier) y la DFT (Transformada de Fourier
discreta).
Scilab para el cálculo de la FFT utiliza la función fft, cuya sintaxis es:
[x]=fft(a,-1)
[x]=fft(a,1)
x=fft(a,-1,dim,incr)
x=fft(a,1,dim,incr)
Para este caso:
x = vector real o complejo. Matriz real o compleja (2-dim fft)
a = vector real o complejo.
Dim = entero
14
Incr = entero
A continuación se muestra un ejemplo de una función coseno que es transformada
mediante la fft:
x=0:63;y=cos(2*%pi*x/16);
yf=fft(y,-1);
plot(y); //Función coseno sin filtrar;
plot(x,real(yf)’); // DFT de la función coseno.
La siguiente figura muestra la señal de la función coseno sin haber aplicado la fft.
Figura 2.3 Función coseno sin filtrar.
15
Al tomar la DFT de la función mostrada en la figura 2.3 obtenemos el gráfico
siguiente.
Figura 2.4 Transformada discreta de Fourier de la señal coseno.
Si lo que deseamos es hallar la transformada discreta de Fourier la sintaxis es:
[xf]=dft(x,flag);
En donde:
x: es el vector de entrada.
flag: indica dft (flag=-1) o idft(flag=1).
xf : es el vector de salida.
g) Convolución.
La convolución es definida como:
y k =∑ h j∗x k1− j
j
(2.2-15)
16
Scilab estima la convolución usando el método de la suma coincidente. Este es un
algoritmo basado en la definición de convolución y es implementado por un producto de
polinomios, el cual es mucho más eficiente si x es un arreglo extenso.
Para poder realizar la convolución SCILAB tiene la función convol la cual, presenta
tres tipos de sintaxis distintas.
-->y=convol(h,x)
-->[y]=convol(h,x)
-->[y,e1]=convol(h,x,e0)
En donde:
h: vector de la primera secuencia de entrada.
x: vector de la segunda secuencia de entrada.
e0: un vector, última cola de la suma en solaparse (no se usa en el primer llamado).
e1: nuevo vector de la suma en solaparse (no usado en el último llamado)
h) Chirp Z-transform (CZT).
Hay aplicaciones donde se requiere calcular muestras de la transformada Z dentro o
fuera del círculo unitario, o con diferente espaciamiento angular en el círculo unitario. Un
eficiente algoritmo que puede ser usado para calcular muestras de la transformadas Z en
estas aplicaciones, es conocido como chirp Z-transform (CZT) . En particular la CZT puede
ser usada como un eficiente algoritmo para el cálculo de valores de la transformada Z de un
17
ancho finito, para una secuencia de tiempo discreto, donde los puntos de la transformada Z
tienen la forma:
Z k = AW −k
(2.2-16)
A= Ao e j
(2.2-17)
Donde
− j
W =W o e
(2.2-18)
Y donde A0 y W0 son valores reales constantes y θ y Φ son ángulos.
Figura 2.5 Localización de las muestras de la transformada Z para Wo < 1 y Wo > 1. Referencia (1).
El grupo de puntos {zk} se encuentra sobre la espiral donde z0 está a una distancia
A0 del origen y en un ángulo θ del eje x. Los puntos restantes son localizados a iguales
ángulos Φ entre ellos y aproximándose al origen por Wo > 1, moviéndose desde el origen
por W0 < 1, y permaneciendo en un círculo de radio A0 para W0 =1, la figura 2.5 indica la
localización de las muestras de la transformada z para Wo < 1 en el lado izquierdo de la
figura y Wo > 1 en el lado derecho de la figura.
La sintaxis de la CZT es la siguiente:
18
-->[czx]=czt(x,m,w,phi,a,theta);
En donde los parámetros son:
x: secuencia de entrada.
m: es el valor CZT en m puntos del plano z.
W: multiplicador de magnitud.
Phi: incremento de fase.
a: magnitud inicial.
theta: fase inicial.
czx: salida de “chirp z transform”.
2.2.2
Diseño de filtros con Scilab.
La teoría general del diseño de Filtros Digitales nos conduce al agrupamiento de las
funciones para el diseño en cuatro métodos:
Diseño de filtros IIR usando prototipos analógicos.
Diseño de filtros IIR directo.
Diseño de filtros FIR directo.
Diseño de filtro inverso.
a) Diseño de filtros FIR (Finite Impulse Response).
Como usar el comando wfir
Esta función puede tener dos tipos de sintaxis, la primera de ellas:
19
--> [wft,wfm,fr]=wfir()
Donde el paréntesis es una parte requerida del nombre. Este tipo de función es
interactiva y propone el uso de parámetros de entrada requeridos, semejantes al tipo de
filtro (lp = paso bajo, hp = paso alto bp = paso banda, sp = rechaza banda), el ancho del
filtro (un integer n > 2), tipo de ventana (re = rectangular, tr = triangular, hm = hamming, kr
= kaiser, ch = chebyshev) y otro parámetro especial para hacer generalizaciones de la
ventana Hamming (0 < < 1) y para la ventana Kaiser ( > 0). Los tres retornan
argumentos como:
wft:: un vector contiene los coeficientes de ventana del filtro para un ancho de filtro
“n”.
wfm: un vector de 256 de ancho contiene la respuesta en frecuencia del filtro al cual
se le aplicó la ventana.
fr: un vector de 256 de ancho contiene los valores de frecuencia de los ejes (0 < fr <
0,5) asociado al valor contenido en wfm.
La segunda sintaxis de la función es la siguiente.
--> [wft,wfm,fr] =wfir(ftype,forder,cfreq,wtype,fpar)
Esta forma de la función no es interactiva y todos los parámetros de entrada deben
ser dados como argumentos de la función.
Ftype: indica el tipo de filtro a construir y puede tomar valores de lp, hp, bp y sb
representando paso bajo, paso alto, paso banda y rechaza banda respectivamente.
Forder: es un integer positivo que da el orden del filtro elegido.
20
Cfreq: es un vector-dos para el cual solo el primer elemento es usado para el caso de
filtros paso bajo y paso alto. Bajo estas circunstancias cfreq(1) es la frecuencia de corte
(“cut-off frequency”) en Hertz del filtro escogido. Para el pasa banda y el rechaza banda
ambos elementos de cfreq son usados, el primero de ellos es la frecuencia baja de corte y el
segundo la frecuencia alta de corte del filtro. Ambos valores de cfreq deben estar entre 0 y
0.5 correspondiendo a los posibles valores de una respuesta de frecuencia discreta.
Ftype indica el tipo de ventana escogida y puede tomar valores de re, tr, hm, hn, kr,
o ch
representando respectivamente las ventanas rectangular, triangular, Hamming,
Hanning, Kaiser y Chebyshev.
Fpar es un vector de dos valores para el cual solo el primer valor es usado para el
caso del uso de la ventana Kaiser y solo en la ventana Chebyshev se usan ambos elementos.
En el caso de la ventana Kaiser el primer elemento indica el cambio relativo entre el lóbulo
principal de la respuesta en frecuencia de la ventana y el ancho del lado del lóbulo (debe ser
un entero positivo). Para la ventana Chebyshev se puede especificar el ancho del lóbulo
principal de la ventana o el tamaño de los lados del lóbulo. El primer elemento de fpar
indica el tamaño del lado del lóbulo y toma valores con rangos entre 0 y 1 y el segundo
elemento da el ancho del lóbulo principal el cual puede tener valores entre 0 y 0.5. el
elemento especificado del vector fpar es indicado asignando un valor negativo. De esta
manera fpar = [0.01, -1] significa que la ventana Chebyshev tiene los lados del lóbulo de
un tamaño 0.01 y el ancho del lóbulo principal izquierdo no especificado.
Debido a las propiedades lineales de los filtros de fase lineal FIR no es posible
diseñar un filtro paso alto de un ancho regular o un filtro rechaza banda.
21
b) Técnicas de muestreo de frecuencia.
Esta técnica es basada en un grupo especificado de muestras que se eligen de la
respuesta en frecuencia tomada con N puntos espaciados uniformemente alrededor de un
círculo unitario, donde N es la longitud del filtro. Según la referencia (1) la transformada z
de un filtro FIR es mostrada de la siguiente forma:
N −1
H k
z−N
H z =1−
∑
N k =0 1−z −1 e j 2 / N k
(2.2-19)
Esto significa que una aproximación de respuesta en frecuencia continua se obtiene
tomando un muestreo en frecuencia con N puntos equidistantes alrededor del círculo
unitario (la frecuencia de muestreo), e interpolando entre estos obteniendo la respuesta en
frecuencia continua. De esta forma el error de aproximación podría ser exactamente cero
en las frecuencias de muestreo y finito entre estos. Este factor tiene que ser relacionado a la
construcción de una función continua para estas muestras.
La fórmula de interpolación para un filtro FIR, que ésta en esta respuesta de
frecuencia, es obtenido al evaluar la ecuación anterior en el circulo unitario.
N −1
H e jw =
{
[H k e− jk / N sin Nw /2]
e− jw N −1 /2
∑
N
[sin w /2−k / N ]
k =0
H e jw =
}
(2.2-20)
N −1
e− jw N −1 /2
∑ H k S w , k
N
k =0
(2.2-21)
Donde
S w , k =e− jk / N
sin Nw / 2
sin N w /2−k / N
=±e− jk / N
(2.2-22)
sin w /2−k / N
sin w / 2−k / N
22
La ecuación 2.2-22 muestra las funciones interpoladas. De esta forma, cada
frecuencia muestreada de la respuesta en frecuencia continua es proporcional a la
interpolación sin(Nw/2)/sin(w/2) sustituyendo por k / N
en frecuencia. La principal
deficiencia de esta técnica es la carencia de flexibilidad al especificar la transición del
ancho de banda, el cual es igual al número de muestras elegidas en el tiempo π/N y de esta
manera esta fuertemente relacionado a N. Esto genera un pequeño rizado cerca del flanco
de la banda.
La figura 2.6 muestra la respuesta obtenida por un filtro paso banda tipo 1 con una
longitud de 65. La primera respuesta es obtenida sin muestras en la banda de transición y la
segundo con un muestreo de magnitud 0.5 en cada una de las bandas. Dependiendo de
donde ocurra la frecuencia de muestreo, se dan dos distintos grupos de frecuencias de
muestreo correspondientes a los llamados filtros FIR tipo 1 y tipo 2.
f k=
f k=
k
k =0,... , N −1 para filtro tipo 1
N
k 1 /2
k =0,... , N −1 para filtro tipo 2
N
(2.2-23)
(2.2-24)
23
Figura 2.6 Filtro pasa banda tipo 1 sin muestra y con muestra en cada banda de transmición.
Referencia (1).
Para obtener esta figura se tiene el siguiente código:
hd=[0*ones(1,15) ones(1,10) 0*ones(1,39) ];//muestras tomadas
hst1=fsfirlin(hd,1);//filtro sin muestras en la transición.
hd(15)=0.5;hd(26)=0.5;//muestras en la banda de transición
hst2=fsfirlin(hd,1);//filtro correspondiente
pas=1/prod(size(hst1))*.5;
fg=0: pas:0.5;// grid de frecuencia normalizada
n=prod(size(hstl))
n= 257.
24
plot (fg(1:n),hst1);
plot2d(fg(1:n)', hst2');
El tipo de diseño deseado depende de la aplicación. Por ejemplo, un corte de banda
puede ser más cerrado en los puntos de frecuencia muestreada en un filtro tipo 1 que en un
filtro tipo 2. La siguiente figura muestra estos puntos para un filtro paso bajo con una
longitud 64 y sin muestrear en la banda de transición.
Figura 2.7 Filtro paso bajo tipo 1 y tipo 2. Referencia (1).
El código para generar esta figura es:
-->hd =ones (1,32); hd(65)=0;//definición de muestras
-->hst1=fsfirlin(hd,1);//filtro tipo 1
-->hst2=fsfirlin(hd,2);//filtro tipo 2
-->pas=1/prod(size(hst1))*0.5;
-->fg=pas:pas:0.5;//grid de frecuencia normalizada.
-->plot2d([fg;fg]',[hst1;hst2]');
25
La línea rellena da la respuesta aproximada para el filtro líneal FIR tipo 1.
2.2.3 Manipulación de sonido en SCILAB.
SCILAB permite agregar archivos de audio tipo wav, permitiendo modificar estos a
gusto utilizando filtros y otras formas de alteración. Además permite graficar la
frecuencia de una señal de sonido y generar sus propios sonidos si es requerido y así
poder salvar estos como archivos tipo wav. Esto es de gran utilidad, ya que, permite
mostrar la eficiencia y funcionamiento de otras funciones y propiedades de este
software.
Para graficar la frecuencia de una señal de audio se utiliza la función analyze la cual
tiene la siguiente sintaxis.
-->analyze(w[,fmin,fmax,rate,points])
En donde:
fmin: es un escalar cuyo valor por defecto es de 100 e indica la frecuencia mínima de la
gráfica.
Fmax: es un escalar y determina la frecuencia máxima de la gráfica cuyo valor por
defecto es de 1500.
w: es la señal a graficar.
Rate: es la velocidad de muestreo y tiene un valor por defecto de 22050.
points: marca el número máximo del largo de los datos y posee un valor por defecto
de 8192.
26
Es posible cargar un archivo de sonido en SCILAB; para ello, se utiliza la función
loadwave. Esta función carga un archivo se sonido tipo wav en un vector de salida X
mediante la sintaxis:
-->X=loadwave('nombre del archivo');
SCILAB puede además generar la gráfica de un mapa de sonido mediante la
secuencia llamada mapsound cuya sintaxis es:
-->mapsound (w,dt,fmin,fmax,simpl,rate).
Esta función lleva a cabo la FFT en incrementos de tiempo “dt” (con un valor por
defecto de 0.1), donde “rate” es la velocidad de muestreo, simpl son los puntos
muestreados. fmin y fmax marcan los límites de frecuencia del mapa de sonido de la señal
de entrada w.
Finalmente es posible guardar un archivo de sonido empleando la función savewave la cual
salva un determinado sonido en un vector “x” a una razón de velocidad “rate”. Para esta
función la sintaxis es:
-->savewave('nombre del archivo',x[,rate]);
2.2.4
Gráficas
Como se menciono anteriormente para poder graficar una función, SCILAB utiliza la
función plot y plot2d.
La función plot realiza la gráfica de un grupo de curvas 2D utilizando una de las
siguientes sintaxis:
-->plot (y, <linea_especial>, <propiedad_global>)
27
-->plot(x,y, <linea_especial>, <propiedad_global>)
-->
plot(x1,y1,<linea__especial1>,<propiedad_global_1>,x2,y2,<linea_especial_2>,
<propiedad_global_2>, ..., xN,yN,<linea_especial_N>,<propiedad_global_N>)
En donde:
x: es una matriz o vector real.
y: es una matriz o vector real.
<linea_especial>: es un argumento opcional que debe ser un arreglo y ha de ser
utilizado como una conexión a especificar una ruta de dibujo de la línea. Esta determina el
estilo de la línea y el color.
<propiedad_global>: Este argumento representa una secuencia de acoples de estados
{nombre_de_la_propiedad,valor_de_la_propiedad} que define las propiedades globales del
objeto aplicadas a todas las curvas creadas en estas gráficas.
Para graficar un vector o matriz versus otro vector o matriz se utiliza la función
plot2d, cuya sintaxis es:
plot2d([x],y)
plot2d([x],y,<opta_args>)
En donde:
x: es un vector o matriz real, la cual si se omite, es asumida como un vector 1:n donde
“n” es el número de puntos dados por el parámetro “y”.
y: es una matriz o vector real.
<opt_args>: este representa una secuencia de estados key1=valor1, key2=valor, ...,
donde key1, key2, ... pueden ser uno de los siguientes argumentos.
28
•
Style: grupos de estilos de cada curva. Es asociado a valores que podrían ser
un vector real con valores enteros (positivos o negativos).
•
Rect: número de saltos mínimos requeridos por la gráfica. El valor asociado
podría ser un vector real con 4 enteros [xmin,ymin,xmax,ymax].
•
Logflag: altera la escala de los ejes (lineal o logarítmica). Puede se un arreglo
con posibles valores: “nn”, “nl” y “ll”.
•
Frameflag: controla la computación de los rangos coordinados actuales para
los mínimos valores requeridos. Puede ser un valor entero con rango de 0 a 8.
•
axesflag: especifica como los ejes deben ser dibujados. Es un entero cuyo
valor va en un rango de 0 a 5.
•
nax: grupos de etiquetas de ejes y definición de tics. Es un vector real con 4
enteros [nx,Nx,ny,Ny].
•
leg: grupo de leyendas de curvas. Se asocia a un arreglo de caracteres.
2.3 SCICOS
SCICOS es la herramienta informática para modelado y simulación del software
científico SCILAB. SCICOS modela los sistemas físicos mediante bloques interconectados.
El usuario puede crear sus propios bloques que son programables a través de SCILAB, C o
FORTRAN, siendo útil también para los usuarios de MATLAB, ya que pueden desarrollar
el código en MATLAB y traducirlo a SCILAB, mediante una herramienta de traducción
que incluye SCILAB.
29
SCICOS tiene la capacidad de modelar sistemas dinámicos, ya sean sistemas discretos
o continuos. Incluye además un editor gráfico para la construcción de modelos mediante
inter conexión de bloques. Estos bloques representan funciones fundamentales predefinidas
en SCILAB o definidas por el usuario.
Para
cada señal en SCICOS se asocia un conjunto de índices de tiempos de
activación, llamados tiempos de activación sobre los que la señal puede evolucionar. Fuera
de estos tiempos de activación las señales de SCICOS permanecen contantes según se
muestra en la siguiente figura.
Figura 2.8 Filtro paso bajo tipo 1 y tipo 2. Referencia (2).
El conjunto de tiempo de activación es una unión de intervalos de tiempo y puntos
aislados llamados eventos (events). Las señales en SCICOS son generadas por bloques
(blocks) controlados por señales de activación, que hacen que los bloques produzcan una
30
salida a partir de su entrada y de su estado interno. La señal de salida hereda del bloque que
le ha generado, el conjunto de tiempos de activación (activation time set), pudiéndose usar
esta para controlar otros bloques.
Para mostrar la estructura de los bloques se muestra la siguiente imagen de dos
bloques de SCICOS.
Figura 2.9 Estructura de los bloques en SCICOS. Referencia (2).
En la parte superior de los bloques se muestra las entradas para las señales de
activación (activation input ports) de los bloques. Cuando un bloque no posee entradas de
activación se encuentra permanentemente activo, sin embargo recibe sus tiempos de
activación a partir de sus señales de entrada (input signals).
En la parte inferior del bloque se presentan las salidas de activación (activation output
ports), estas son consideradas como señales de activación generadas por los bloques.
31
2.3.1
El editor de SCICOS
En SCICOS se llama super bloques a los subsistemas que forman un único bloque
partiendo de un grupo de bloques simples.
Para abrir la ventana principal de SCICOS se debe teclear scicos() en SCILAB. Luego
de ello aparecerá la ventana principal de SCICOS, esta ventana es como se muestra en la
siguiente imagen.
Figura 2.10 Ventana principal de SCICOS. Referencia (2).
2.3.2 Construcción de un modelo en SCICOS.
Para construir los modelos de sistemas en SCICOS se realizan los siguientes pasos:
32
Abrir las paletas de bloques: en el menú Edit se encuentra el botón Palettes, que
permite abrir una o más paletas de bloques. Luego de dar clic aparece una ventana de
diálogo, donde se elije la paleta deseada.
La siguiente figura muestra la ventana de diálogo.
Figura 2.11 Ventana de elección de paletas.
Entre las paletas se tienen las de:
•
Paletas de Entradas/Salidas.
•
Paleta Lineal
•
Paleta No Lineal.
•
Paleta de Eventos.
•
Paleta de Umbral (Threshold).
33
•
Paleta Otros.
•
Paleta de Bifurcación.
Al realizar un clic en el botón copy del menú Edit, es posible copiar bloques en la
ventana principal de SCICOS desde las paletas. Se puede además hacer clic con el botón
izquierdo y arrastrar el bloque a la ventana principal. También es posible cancelar la
selección con el botón derecho del ratón. Para borrar un bloque se hace clic en Delete del
menú Edit y hago clic sobre el bloque a borrar.
Para conectar las entradas y salidas de los bloques, se selecciona primero el botón
Link del botón Edit. Luego se hace clic en la salida de un bloque y nuevamente en la
entrada a la que dejamos enviar la señal, quedando ambos conectados. También se puede
partir o terminar en puntos intermedios en los enlaces. Para acabar el proceso de enlazado
solamente se debe de hacer clic con el botón derecho del ratón.
Cabe recalcar que se debe incluir un bloque scope o
write to file, para poder
visualizar los datos de una simulación.
Con nuestro modelo ya completo se puede realizar una simulación usando el botón
Run del menú Simulate. Esto provoca la compilación del modelo y después la simulación.
La simulación se puede detener haciendo clic sobre el botón Stop
en la ventana de
SCICOS.
Finalmente un modelo compilado puede ser salvado como un fichero *.cos.
34
Podemos modificar los parámetros de los bloques abriendo los menús de diálogos, al
seleccionar el botón Open/set del menú Object.
Los parámetros pueden ser definidos utilizando expresiones de SCILAB e incluso se
puede utilizar variables de SCILAB si ya han sido definidas. Estas expresiones son
memorizadas simbólicamente y evaluadas posteriormente.
El editor SCICOS proporciona muchas otras funcionalidades como por ejemplo:
•
Salvar y cargar diagramas de modelos en varios formatos.
•
Ampliación de zonas de modelos.
•
Cambio de aspecto de los bloques y colores.
•
Cambio de color de fondo de los diagramas de los modelos y de los bloques.
•
Adherir textos al diagrama.
•
La posibilidad de imprimir y exportar diagramas.
•
Y muchas otras funciones GUI estándar.
La ayuda de la ventana principal de SCICOS puede usarse seleccionando el botón de
ayuda y haciendo clic sobre el bloque o botón del cual deseo información.
Al implementar la programación de nuevos bloques puedo obtener información de las
funciones a utilizar desde la ventana principal de SCILAB haciendo clic en el botón Help
Dialog del menú Help. Aparece entonces una ventana en la que elijo SCICOS en la parte
inferior Chapters y selecciono en la zona superior la función de la que quiero ayuda y
pulso el botón Show.
35
Figura 2.12 Ventana de ayuda a través de SCILAB. Referencia(2).
Si deseo ejecutar los demos de SCICOS hago clic en el botón Demos del menú File
en la ventana principal de SCILAB, en el que aparece el cuadro de diálogo siguiente:
Figura 2.13 Cuadro de diálogo de selección de demos.
36
Luego selecciono SCICOS y hago clic en el botón OK, apareciendo otra ventana con
todos los demos disponibles para SCICOS, seleccionando el que se desea ejecutar y
haciendo clic en el botón OK.
Una importante característica de SCICOS es la posibilidad de generar subsistemas en
donde se generan agrupaciones de bloques. Para esto se da la posibilidad de agrupaciones
de bloques definiendo subdiagramas llamados Super Bloques
(Super Blocks), que se
comportan como cualquier otro bloque pero pueden contener un número ilimitado de
bloques, e incluso otros super bloques. Los super bloques tienen la siguiente apariencia:
Figura 2.14 Apariencia de un super bloque.
Al hacer doble clic sobre un super bloque podemos observar todos los bloques que
contiene.
2.3.3
Tipos de bloques en SCICOS
Existen tres tipos de bloques fundamentales en SCICOS: el bloque normal, el bloque
de cruce y el bloque sincronizado. Estos pueden tener dos tipos de entradas y dos tipos de
salidas, entradas normales, entradas de activación, salidas normales y salidas de activación.
Las entradas y salidas normales se conectan mediante enlaces normales, mientras que las
entradas y salidas de activación se conectan mediante enlaces de activación.
37
a) Bloque normal simple continuo.
Los bloques normales simples continuos pueden tener un estado continuo x y un
estado discreto z. Al considerar que tiene un estado continuo x y si su entrada normal es u,
entonces cuando el bloque esté activado durante un intervalo de tiempo, su estado x
evoluciona de acuerdo con:
ẋ= f t , x , z , u , p , ne
(2.3-1)
p es un vector de parámetros constantes, ne es la clave de activación representada por
un entero designando el puerto a través del cual es activado. En el caso en que las entradas
de activación sean i1, i2, ..., in entonces.
n
n e =∑ 2i −1
j=1
(2.3-2)
j
Por otro lado si el bloque estuviera activado por un evento, los estados x y z cambian
instantáneamente de acuerdo con las siguientes ecuaciones.
x t e = g c t e , x t e , z t e , u t e , p , n e
(2.3-3)
z t e =g d t e , x t e , z t e , u t e , p , ne
(2.3-4)
−1
−1
−1
−1
Donde te representa el tiempo en el que se produce el evento y el estado discreto z
permanece constante entre dos eventos sucesivos, luego z(te-) puede ser interpretado como
el valor previo de z. Durante el tiempo de activación, la salida normal del bloque viene
definida por:
38
−1
−1
y t=ht , x t , z t , u t , p , ne
(2.3-5)
Que será constante cuando el bloque no esté activo.
Este tipo de bloques puede generar señales de activación de tipo evento. Si esta señal
es activada por un evento en el instante te, entonces el tiempo de cada salida tipo de evento
viene dado por:
t evo =k t e , z t e ,u t e , p , ne
(2.3-6)
Donde tevo es un vector de tiempo. La generación de eventos puede ser preprogramada
asociando las variables de disparo de los bloques con la salida de eventos.
Figura 2.15 Bloque normal simple continuo. Refrencia (2).
39
b) Bloque normal simple discreto.
Un bloque normal continuo está constantemente actualizando sus salidas y su estado
continuo. Los bloques normales simples discretos actúan solo cuando reciben un evento de
entrada y sus acciones son instantáneas por lo que deben tener una entrada evento como
mínimo. Si se tiene una señal de entrada u y una señal de salida y, con la llegada de un
evento o eventos en un tiempo (te), entonces su estado y sus salidas cambiarán de la
siguiente forma.
z := f d t e : z t e : u t e : p : n evprt
(2.3-7)
y :=h d t e : z : u t e : p
(2.3-8)
−1
−1
Donde fd y hd son funciones específicas del bloque, p es un vector de parámetros
constante y nevprt designa el puerto (s) a través del cual el evento ha llegado. Los bloques
discretos no pueden tener un estado continuo y sus salidas permanecen constantes entre dos
eventos; no igual sucede en los bloques continuos.
40
Figura 2.16 Bloque normal simple discreto. Referencia (2).
c) Bloque simple de cruce por cero.
Tienen entradas de señales normales, entradas y salidas de eventos pero no pueden
tener señales de salidas normales. Tiene la capacidad de generar un evento de salida
solamente si al menos una de sus entradas normales cruza el cero (cambia de signo). Si esto
ocurre se genera un evento y su tiempo de activación dependerá del cruce por cero de las
señales de entrada y del signo de ellas justo luego del cruce.
41
Figura 2.17 Bloque simple de cruce por cero. Refrencia (2).
d) Bloque simple sincronizado
Generan señales de salida de activación que están sincronizadas con sus señales de
entradas de activación. Solo poseen una entrada de activación, que es dirigida a una de sus
salidas de activación. La elección de una de estas salidas depende del valor de la señal de
entrada normal. Algunos ejemplos de estos tipos de bloques son los bloques if, else, then,
event y select.
42
Figura 2.18 Bloque simple sincronizado. Refrencia (2).
e) Herencia y dependencia temporal
Para evitar que se tengan que dibujar todas las señales de activación de un diagrama
en SCICOS, se utiliza la característica llamada herencia. Si un bloque no tiene una entrada
de activación que regule la señal de entrada normal y está activo permanentemente, se le
puede declarar como dependiente del tiempo y no es necesaria la entrada de activación. Es
importante decir que los bloques dependientes del tiempo no heredan.
2.3.4
Construcción de nuevos bloques.
Al construir un nuevo bloque este puede ser generado como un superbloque
(mediante la interconexión de otros bloques simples) compilándose luego. También se
puede crear un nuevo bloque simple mediante las dos funciones siguientes:
43
Función interfaz (Interfacing funtion) que determina la interfaz con el usuario. Esta
función esta siempre escrita en código SCILAB, pudiéndose utilizar funciones SCILAB o
que sean desarrolladas por el usuario.
Función computacional (Computational function) esta función permite especificar el
comportamiento dinámico del bloque. Posee una amplia flexibilidad al poder ser
programada en C, Fortran y en lenguaje SCILAB; interactúa permanentemente dando
mejores resultados en lo que concierne al rendimiento de la simulación.
La función interfaz determina tamaño, color, geometría, número de puertos, etc. en
adición con los estados inicial y los parámetros. Esta función también proporciona el
diálogo del usuario con el bloque. La funcionalidad y respuesta de esta función depende de
la variable de entrada de estatus (input flag) job.
Sintaxis
-->[x,y,typ]=block(job,arg1,arg2)
Parámetros:
job =='plot' : la función dibuja el bloque.
arg1 es la estructura de datos del bloque
arg2 no se usa.
x,y,typ no se usa.
Podemos usar la función standard_draw la cual dibuja un bloque rectangular, y los
puertos de entrada y de salida. También determina el tamaño, icono y color que dan el
aspecto al bloque.
44
Job=='getinputs':la función retorna la posición y el tipo de puertos de entrada (normal
o activación).
Arg1 es la estructura de datos del bloque
arg2 no se usa
x es el vector de las coordenadas x de los puertos de entrada.
Y es el vector de las coordenadas y de los puertos de entrada.
Typ es el vector del tipo de puertos de entrada (1 para regular y 2 para activación)
En general podemos usar la función standard_input.
Job =='getoutput' : la función retorna la posición y el tipo de puertos de salida (nomal
o activación)
x es el vector de las coordenadas de x de los puertos de salida
y es el vector de las coordenadas de y de los puertos de salida
typ es el vector del tipo de puertos de salida (1 para regular y 2 para activación)
En general podemos utilizar la función standard_output.
Job=='getorigin' : la función retorna las coordenadas del punto interior izquierdo del
rectángulo que contiene la silueta del bloque.
x es el vector de las coordenadas de x del punto inferior izquierdo del bloque
y es el vector de la coordenada y del punto inferior izquierdo del bloque.
En general podemos utilizar standard_origin.
Job=='set' : la función abre un diálogo para adquirir los parametros del bloque.
x es la nueva estructura de datos del bloque
y no se usa
45
typ no se usa
En general podemos usar la función standard_origin.
Job == 'define' : inicialización de la estructura de datos del bloque (nombre de la
función computacional, tipo, número y tamaño de las entradas y salidas, etc.)
arg1 no se usa
arg 2 no se usa
x es la estructura de datos del bloque
y no se usa
typ no se usa.
Definición de la estructura de datos del bloque.
2.3.5
Los bloques en SCICOS están definidos por una estructura de datos SCILAB como
sigue:
list ('block',graphics,model,ununsed,GUI_function)
GUI_function es una cadena de caracteres (string) que contiene el nombre de la
correspondiente función interfaz y graphics es la estructura de datos que contiene los datos
gráficos:
graphics=list ([xo,yo],[l,h],orient,dlg,pin,pout,pcin,pcout,gr_i)
Xo coordenada x del origen del bloque
Yo coordenada y del origen del bloque
l ancho del bloque
46
h altura del bloque
orient es un booleano
dlg es un vector de cadenas de caracteres que contienen los parámetros simbólicos
del bloque.
Pin vector, pin(i) es el número de enlace conectado al puerto de entrada normal iésima y es 0 cuando no están conectados.
Pout vector, pout(i) es el número de enlace conectado al puerto de salida normal iésima y es 0 cuando no están conectados.
Pcin vector, pcin(i) es el número de enlace conectado al puerto i de entrada de
activación i-ésima y es 0 cuando no están conectados.
Pcout vector, pcout(i) es el número de enlace al puerto de salida de activación i-ésima
y es 0 cuando no están conectados.
gr_i vector de cadena de caracteres que contiene las instrucciones usadas para dibujar
el icono.
La estructura de datos que contiene la información de la simulación es model.
Model=list(eqns,numinput,numoutput,numclk_input,numclk_output,state,dstate,rpar,i
par,typ,firing,deps,label,unused)
eqns lista que contiene dos elementos. El primero es una cadena que contiene el
nombre de la función computacional (FORTRAN, C o función SCILAB). El segundo
elemento es un entero que especifica el tipo de función computacional. El tipo de función
computacional especifica básicamente la secuencia de llamada.
47
Numinput vector de tamaño igual al número de puertos de entrada normales del
bloque. Cada entrada muestra el tamaño del correspondiente puerto de entrada. Un entero
negativo indica que debe ser determinado por el compilador. Si damos el mismo entero
positivo en más de un puerto de entrada o salida indica al compilador que esos puertos
tienen igual tamaño.
Numoutput vector de igual tamaño al número de puertos de salidas normales del
bloque. Si se tiene un entero negativo indica que debe ser determinado por el compilador.
Si muestra el mismo entero negativo en más de un puerto de entrada o salida indica al
compilador que esos puertos tienen igual tamaño.
numclk_input vector de tamaño igual al número de puertos de entrada de activación.
Todas las entradas deben ser iguales a 1. SCICOS no soporta enlaces de activación
vectorizados.
numclk_output vector de tamaño igual al número de puertos de entrada de activación.
Todas las entradas deben ser iguales a 1. SCICOS no soporta enlaces de activación
vectorizados.
State vector columna que contiene el estado continuo inicial
dstate vector columna de parámetros reales pasados a la correspondiente función
computacional.
Rpar vector columna de parámetros reales pasados a la correspondiente función
computacional.
Ipar vector columna de parámetros enteros pasados a la correspondiente función
computacional.
48
Typ cadena que indica el tipo de bloque simple : 'z' = bloque de cruce por cero, 'i' =
bloque sincronizado y 's' = bloque normal.
Firing vector columna de los tiempos de disparo inicial de tamaño igual al número de
puertos de salida de activación del bloque. Este vector incluye tiempos de disparo de
eventos pre programados (<0 si no hay disparo).
Deps [udep timedep]
udep booleano. True si el sistema tiene alimentación directa, o sea que al menos una
de las salidas depende explicitamente de una de las entradas.
Timedep booleano. Verdad si el bloque es dependiente temporalmente.
Label cadena de caracteres, usada como identificador del bloque. Este campo puede
ser seleccionados en el botón label del menú block.
2.3.6
Función computacional
Esta función evaluá la salida dependiendo del tipo de bloque y la forma que sea
llamada por el simulador.
El simulador SCICOS llama a la función computacional para realizar diferentes tareas
(task), utilizando una variable status (flag) para especificar la tarea que se debe ejecutar,
como se muestra en la tabla.
49
Tabla 2.1 Status de la función computacional.
Status (flag)
Tarea (task)
0
Estado derivativo computacional
0
estado derivativo computacional
1
outputs update
2
state update
3
output event timing
4
initialization
5
ending
6
re-initialization
Inicialización: el simulador llama a la función computacional para conocer el estado
del arranque y la salida de inicialización (las entradas no se encuentran disponibles en el
momento de arranque). Otras tareas como abrir un fichero, inicialización de la ventana
gráfica, etc..., pueden también ser ejecutadas en este punto.
Reinicialización: el simulador puede llamar al bloque un determinado número de
veces para la inicialización. Esta representa otra oportunidad para iniciar los estados y las
salidas. Pero esta vez, las salidas se encuentran disponibles.
50
Actualización de las salidas: El simulador llama para obtener los valores de las
salidas. De esta manera la función computacional debería evaluar el status (4) mostrado en
la tabla 2.1..
Actualización de los estados: Uno o más eventos han llegado y el simulador llama a la
función computacional para actualizar los estados x y z de acuerdo con los status (2) y (3)
de la tabla 2.1.
Cálculo del estado derivado: El simulador se encuentra en una fase continua; y se
necesita la derivada de x. Esto significa que la función computacional debe evaluar el
estado derivativo computacional..
Tiempo de salida de eventos: El simulador llama a la función computacional en el
tiempo de sus eventos de salida. Para realizar esto la función computacional deberá evaluar
el status (5) de la tabla 2.1.
Terminación: El simulador llama a la función computacional una vez más al final (es
útil para cerrar ficheros, liberar la memoria, etc..).
51
a) Tipos de funciones computacionales.
En SCICOS las funciones computacionales pueden ser de diferentes tipos y coexistir
en un mismo diagrama de un modelo. Los tipos de funciones existentes vienen
especificados en la siguiente tabla.
Tabla 2.2 Tipos de función.
Tipo de función
SCILAB
Fortran
C
Comments
0
si
si
si
Fixed calling
sequence
1
no
si
si
Varying calling
sequence
2
no
no
si
Fixed calling
sequence
3
si
no
no
Input/outputs are
SCILAB list
El tipo de función computacional utilizada es almacenada en el segundo campo de
eqns.
Función computacional tipo 0: el simulador construye un único vector también. Este
tipo es soportado por versiones de SCILAB anteriores a la 2,4. La secuencia de llamada es
igual que la de la función computacional tipo 1 con una entrada normal y salida normal.
52
Función computacional tipo 1: la forma más sencilla de explicar este tipo es mediante
un ejemplo. Los parámetros (I de entrada y O de salida) que utilizan las funciones tipo 1
son los que muestra la siguiente tabla.
Tabla 2.3 Parámetros de entrada/salida que utilizan funciones tipo 1.
I/O
Args
Descripción
I
flag
0,1,2,3,4,5 o 6
I
Nevprt
Código de activación
I
t
tiempo
o
xdot
Derivada de estados continuos
I/O
x
Estado continuo
I
nx
Tamaño de x
I/O
z
Estado discreto
I
nz
Tamaño de z
O
tvec
Tiempos de salida de eventos (para
flag 3)
I
ntvec
Número de puertos de activación
I
rpar
parámetros
I
nrpar
Tamaño de rpar
I
ipar
parámetros
I
nipar
Tamaño de ipar
I
ui
Ith input (regular), i=1,2,...
I
nui
Tamaño de entrada ith
O
yj
Salida jth (regular) j=1,2,.....
I
nyj
Tamaño de salida jth
53
CAPÍTULO 3: Elaboración de prácticas de procesamiento
digital de señales en SCILAB.
Las prácticas elaboradas fueron tomadas de las prácticas recopiladas del curso
Procesamiento Digital de Señales IE-0102 de la Universidad de Costa Rica. Estas prácticas
que fueron inicialmente elaboradas para ser ejecutadas con MATLAB fueron modificadas
en este capitulo para poder ejecutarlas con SCILAB.
3.1
Primera práctica.
En esta primera práctica se muestra como generar algunas señales y sus gráficas en
forma discreta, en si se generan secuencias exponenciales complejas, real, imaginaria y
como generar señales de ruido. Además se da el suavizamiento de una señal por un filtro
de promedio móvil.
A continuación se muestra la práctica número 1:
Procesamiento Digital de Señales IE-0102
Práctica #1 con SCILAB.
SCILAB incluye un sinnúmero de funciones que pueden usarse para la generación
de señales. Algunas de estas funciones son:
exp, sin.cos, square, sawtooth
El programa que se puede utilizar para generar una secuencia exponencial compleja
es:
54
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 1.1
// Generación de una secuencia exponencial compleja
// a = -1/12; b = %pi/6; K = 1;N = 41;
a = input('Introduzca exponente real = ');
b = input('Introduzca exponente imaginario = ');
c = a + b*%i;
K = input('Introduzca la constante de ganancia = ');
N = input('Introduzca longitud de secuencia = ');
n = 1:N;
x = K*exp(c*n);
f0=scf(0); //crea la figura 0
plot2d3('gnn',n,real(x));xgrid;
xlabel('Indice temporal n');ylabel('Amplitud');
title('Parte real');
disp('Teclee ENTER para la parte imaginaria');
pause
f1=scf(1);
scf(f1);
plot2d3('gnn',n,imag(x));xgrid;
xlabel('Indice temporal n');ylabel('Amplitud');
title('Parte imaginaria');
55
//////////////////////////////////////////////////////////////////////////////////////////////////////
Se procede ahora a generar una secuencia exponencial real en SCILAB:
//////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 1.2
// Generación de secuencia exponencial real
// a = 1.2; K = 0.2; N = 30;
// Pruebe también con
// a = 0.9; K = 20; N = 30
a = input('Introduzca exponente = ');
K = input('Introduzca la constante de ganancia = ');
N = input('Introduzca la longitud de la secuencia = ');
n = 0:N;
x = K*a.^n;
f0=scf(0);club;
plot2d3('gnn',n,x); xgrid;
xlabel('Indice temporal n');ylabel('Amplitud');
title('a=1.2');
disp('Teclee ENTER para continuar');
pause
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Un ejemplo simple de un sistema de tiempo discreto es el filtro de promedio móvil de
M puntos, definido por:
56
M −1
1
∑ x[ n−k ]
M k=0
Este sistema se usa a menudo para “suavizar” variaciones aleatorias en los datos.
y[n ]=
Considérese por ejemplo una señal s[n] corrompida por ruido d[n] para n = 0 , resultando
en datos medidos dados por
x[n ]=s [n ]d[n ]
Sería conveniente reducir el efecto del ruido d[n] para obtener un mejor estimado de
s[n] de x[n]. Para este fin, el filtro de promedio móvil da resultados razonablemente
buenos. Para ilustrar este enfoque, se usará SCILAB. Por simplicidad, suponga que la señal
original sin corromper está dada por
s[n ]=2 [n0.9 n ]
El programa para generar s[n] y d[n] es dado a continuación, donde el ruido d[n] se
calcula usando la función rand.
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 1.3
// Otro ejemplo de generación de señales
// Generación de ruido aleatorio
R = 50;
d = rand(R,1) - 0.5;
// Para generar la señal corrompida
m = [0:1:R-1]';
s = 2*m.*(0.9.^m);
f0=scf;clf;
57
subplot(2,1,1);
plot2d3('gnn',m,s);xgrid;
xlabel('Indice temporal n');ylabel('Amplitud');
title('Secuencia original no corrompida');
subplot(2,1,2);
plot2d3('gnn',m,d);xgrid;
xlabel('Indice temporal n');ylabel('Amplitud');
title('Ruido');
disp('Teclee ENTER para continuar');
pause
///////////////////////////////////////////////////////////////////////////////////////////////////////////
El siguiente programa se usa para generar la salida ‘suavizada’ y[n] de la señal
original corrompida con ruido usando el sistema de promedio móvil. Durante su ejecución,
el programa solicita los datos de entrada, que es el número deseado M de muestras de
entrada a ser promediadas. Para enfatizar el efecto del ensuavizamiento del ruido más
claramente, las señales de tiempo discreto se trafican como curvas continuas usando la
función plot.
En SCILAB se generó el programa:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 1.4
// Suavizamiento de una señal por un filtro de promedio móvil
// M = 3;
58
R = 50;
d = rand(R,1) - 0.5;
m = [0:1:R-1]';
s = 2*m.*(0.9.^m);
x = s + d;
f0=scf(0);clf;
plot(m,d,'r-',m,s,'b--',m,x,'g:');xgrid;
xlabel('Indice temporal n');ylabel('Amplitud');
legend('r-','d[n]','b--','s[n]','g:','x[n]');
disp('Teclee ENTER para realizar el suaviza miento');
pause
M = input('Numero de muestras de entrada = ');
b = ones(M,1)/M;
// y = filter(b,1,x); Esta función sirve en la versión 5.1 de SCILAB.
//En el caso de poseer una versión anterior:
//Tome la carpeta cuyo nombre es DSP y cópiela en el siguiente directorio “macros”
//de SCILAB.
//luego ejecute el comando
//getf('SCI/macros/DSP/filter/filter.sci');
//Después de esto puede usar la función “filter”
//Para más información dimite “ help getf ”.
y = filter(b,1,x);
59
f1=scf(1);clf;
scf(1);
plot(m,s,'r-',m,y,'b--');grid;
legend('r-','s[n]','b--','y[n]');
xlabel('Indice temporal n');ylabel('Amplitud');
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
3.1.1
Resultados para la primera práctica:
Con la finalidad de obtener una comparación entre SCILAB y MATLAB se tienen los
siguientes resultados:
a) Resultados del programa 1.1.
Al ejecutar el programa original en MATLAB se obtuvieron las figuras 3.1 y 3.2.
Figura 3.1 Parte real de la secuencia exponencial compleja realizada en MATLAB.
60
Figura 3.2 Parte imaginaria de la secuencia exponencial compleja realizada en MATLAB.
Se generaron los siguientes resultados con SCILAB.
Figura 3.3: Parte real de la secuencia exponencial compleja realizada en SCILAB.
61
Figura 3.4 Parte imaginaria de la secuencia exponencial compleja realizada en SCILAB.
b) Resultados del programa 1.2
Luego de ejecutar el código anterior se obtiene el siguiente resultado.
Figura 3.5 Generación de secuencia exponencial real con a = 1.2, K = 0.2 y N = 30 en SCILAB.
Figura 3.6 Generación de secuencia exponencial real con a = 0.9, K = 20 y N = 30 en SCILAB.
62
El resultado de generar esta secuencia en MATLAB para a = 1.2, K = 0.2 y N = 30 es
mostrado en la figura 3.7:
Figura 3.7 Generación de secuencia exponencial real con a = 1.2, K = 0.2 y N = 30 en MATLAB.
Figura 3.8 Generación de secuencia exponencial real con a = 0.9, K = 20 y N = 30 en MATLAB.
c) Resultados del programa 1.3
Tras digitar el código en MATLAB se obtiene la próxima figura.
63
Figura 3.9 Señal original no corrompida y señal de ruido generadas con MATLAB.
Se muestra a continuación el resultado al graficar en SCILAB:
Figura 3.10 Señal original no corrompida y señal de ruido generadas con SCILAB.
64
d) Resultados del programa 1.4
Para este caso se obtienen los resultados mostrados.
Figura 3.11 Señales de entrada y señal sin suavizar en SCILAB
Figura 3.12 Señal original y señal suavizada obtenida con SCILAB.
65
Luego de ejecutar el programa en MATLAB se deben visualizar las siguientes
figuras:
Figura 3.13 Señales de entrada y señal sin suavizar en MATLAB
Figura 3.14 Señal original y señal suavizada obtenida con MATLAB.
66
3.2
Segunda práctica.
En esta segunda practica se muestra la propiedad de convolución entre dos
secuencias, así como el cálculo de la respuesta al impulso, la autocorrelación y una
aplicación de esta.
A continuación se muestra la segunda práctica:
Procesamiento Digital de Señales IE-0102
Práctica #2 con SCILAB.
Convolución
Ejecute el siguiente programa para realizar la convolución de dos secuencias que
usted mismo va a introducir a la computadora. No olvide que, ante cualquier duda acerca de
un mandato de SCILAB, puede escribir help mandato para hacer la debida consulta.
El programa en SCILAB para ilustrar la convolución es el siguiente:
////////////////////////////////////////////////////////////////////////////////////
// Programa 2.1
// Ilustración de la convolución
a = input('Introduzca la primera secuencia = ');
b = input('Introduzca la segunda secuencia = ');
c = convol(a,b);
M = length(c) -1;
n = 0:1:M;
67
disp('Secuencia de salida = ');disp(c)
plot2d3('gnn',n,c);
xlabel('Indice temporal n');ylabel('Amplitud');
////////////////////////////////////////////////////////////////////////////////////
Durante la ejecución, los datos de entrada solicitados son las dos secuencias a
convolucionar que son introducidas en forma vectorial dentro de paréntesis cuadrados
como se muestra:
a = [-2 0
1
-1
3];
b = [1
2
0
-1];
El programa 2.1 calcula la convolución y muestra la secuencia resultante:
Secuencia de salida =
-2
-4
1
3
1
5
1
-3
y la gráfica. Para una comprobación simple, realice la convolución a mano.
Cálculo de la respuesta al impulso
El programa que sigue calcula la respuesta al impulso de un sistema de tiempo
discreto LIT de dimensión finita. Los datos de entrada del programa son la longitud
deseada de la respuesta al impulso y los vectores de los coeficientes del filtro p y d que
deben ser introducidos dentro de paréntesis cuadrados. El programa luego grafica la
secuencia de la respuesta al impulso. Para ilustrar esto, se determina las primeras 41
muestras de la respuesta al impulso del sistema causal LIT definido por la ecuación en
diferencias:
68
y [n]0.7y [n−1]−0.45y [n−2 ]−0.6y [n−3]=0.8x [n]−0.44x [n−1]
0.36x[ n−2]0.02x [n−3]
En SCILAB se presenta el siguiente programa.
/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 2.2
// Ilustración del cálculo de la respuesta al impulso
N = input('Longitud deseada de la respuesta al impulso = ');
p = input('Introduzca el vector p = ');
d = input('Introduzca el vector d = ');
x = [1 zeros(1,N-1)];
y = filter(p,d,x);
//En el caso de poseer una versión anterior o no encontrar la función filter
//Tome la carpeta cuyo nombre es DSP y cópiela en el siguiente directorio
“Scilab-5.1/modules/” de SCILAB.
//luego ejecute el comando
//getf('SCI/modules/DSP/filter/filter.sci');
//Despues de esto puede usar la función “filter”
//De no estar la carpeta modules creela y copie la carpeta
//Para más información digite “ help getf ”.
k = 0:1:N-1;
plot2d3('gnn',k,y);
xlabel('Indice temporal n');ylabel('Amplitud');
69
/////////////////////////////////////////////////////////////////////////////////////////////////////////
Los datos de entrada son:
N = 41;
p = [0.8
-0.44
d = [1
0.7
0.36
0.02];
-0.45 -0.6];
La respuesta al impulso generada por el programa es gráficada. La respuesta al
impulso de un sistema de tiempo discreto de dimensión finita también puede graficarse
usando el mandato impz generado para SCILAB. Para determinar la respuesta al escalón se
reemplaza en el programa anterior el enunciado x = [1 zeros(1,N-1)] con el enunciado x =
[ones(1,N)]. Grafique entonces las primeras 41 muestras de la respuesta al escalón.
Correlación
Considérese las dos secuencias de longitud finita
x[n] = [13
-2
1
2
-1
y[n] = [2-1
4
1
-2
3]
4
4
2];
Para el caso de SCILAB tenemos:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 2.3
// Cálculo de la secuencia de correlación cruzada
//x = [1 3
-2
1
2
-1
//y = [2 -1
4
1
-2
3];
4
x = input('Introduzca la secuencia de referencia = ');
4
2];
70
y = input('Introduzca la segunda secuencia =');
// Calcule la secuencia de correlación cruzada
n1 = length(y) -1;n2 = length(x)-1;
r = convol(x,mtlb_fliplr(y));
k = [(-n1):n2]';
plot2d3('gnn',k,r);
xlabel('Indice de atraso');ylabel('Amplitud');
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Cuando se corre el programa, éste solicita los datos de entrada consistentes de los
vectores x e y, que se introducen dentro de paréntesis cuadrados. Se calcula la secuencia de
correlación cruzada usando el mandato convol (SCILAB) con el vector y invertido en el
tiempo para luego gratificarla.
Use el programa anterior para calcular la secuencia de autocorrelación de una
secuencia de longitud finita. Para ello, el vector x se introduce dos veces conforme el
programa solicita los datos de entrada. Para atraso cero (l = 0), rxx[0] es el valor máximo
como debe esperarse.
Como otra experiencia, calcule la correlación cruzada de x[n] y y[n] = x[n-N] para N
= 4, esto con el fin de apreciar cómo se puede usar para encontrar el valor exacto del
retardo N observando el pico de la correlación cruzada.
71
Adicionalmente, modifique el programa para generar una secuencia formada con la
adición de ruido aleatorio a x[n] usando el mandato rand. Encuentre y gráfique la
autocorrelación de la secuencia corrompida con ruido. Debe encontrar que la
autocorrelación exhibe un pico pronunciado en el valor de l = 0 (atraso cero).
Como observación al margen, nótese que la autocorrelación y la correlación cruzada
pueden computarse usando el mandato xcorr. Sin embargo, los resultados obtenidos de esta
forma son la versión invertida en el tiempo de los resultados hallados usando el programa
2.3. Verifique esta aserción.
Aplicación de la autocorrelación
Se va a determinar el periodo de la secuencia sinusoidal x[n] = cos(0.25ðn), 0≤π≤95
corrompida por ruido aleatorio aditivo de amplitud distribuido uniformemente en el ámbito
[-0.5, 0.5].
Debiera verse del gráfico correspondiente no sólo el pico en el atraso cero, sino
también los picos claramente distintos en atrasos que son múltiplos de 8 indicando el
periodo de la secuencia sinusoidal.
Grafique la autocorrelación rdd[n] del componente de ruido. Véase que rdd[n] muestra
un pico fuerte en el atraso cero pero el resto de las amplitudes son considerablemente
72
pequeñas en los otros valores del atraso debido a que las muestras del ruido no están
correlacionadas entre sí.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 2.4
//
//
Cálculo de la autocorrelación de una secuencia sinusoidal corrompida
por ruido
N = 96;
n = 1:N;
x = cos(%pi*0.25*n); // Se genera la secuencia sinusoidal
d = rand(1,N) - 0.5; // Se genera la secuencia de ruido
y = x + d;
// Se genera la secuencia sinusoidal corrompida por ruido
r = convol(y,mtlb_fliplr(y));
// Calcula la autocorrelación
k = -28:28;
plot2d3('gnn',k,r(68:124));
xlabel('Indice de atraso');ylabel('Amplitud');
3.2.1 Resultados de la segunda práctica.
a) Resultados del programas 2.1
Los resultados obtenidos son:
Para las secuencias
a = [-2 0
1
-1
3]
b = [1
2
0
-1]
Secuencia de salida =
73
–2.
- 4.
1.
3.
1.
5.
1. - 3.
Figura 3.15 Ilustración de convolución en SCILAB.
Luego de realizar esta parte de la práctica en MATLAB se obtine:
Figura 3.16 Ilustración de convolución en MATLAB.
b) Resultados del programa 2.2
Al ejecutar el programa se obtiene.
74
Figura 3.17 Ilustración del cálculo de la respuesta al impulso en SCILAB.
Realizando el análisis en MATLAB se obtiene:
Figura 3.18 Ilustración del cálculo de la respuesta al impulso en MATLAB.
c) Resultados del programa 2.3.
Obtenemos con este programa la siguiente figura:
75
Figura 3.19 Cálculo de la secuencia de correlación cruzada en SCILAB.
Los resultados obtenidos con MATLAB:
Figura 3.20 Cálculo de la secuencia de correlación cruzada en MATLAB.
76
d) Resultados del programa 2.4
Se obtiene con SCILAB las siguientes figuras:
Figura 3.21 Cálculo de la autocorrelación de una secuencia senoidal corrompida por ruido usando
SCILAB.
Para determinar la autocorrelación de rdd[n] se ejecuta el siguiente comando en
SCILAB.
rdd= convol(d,mtlb_fliplr(d)); plot2d3('gnn',k,rdd(68:124));
Figura 3.22 Cálculo de la autocorrelación de rdd usando SCILAB.
77
Las gráficas obtenidas de ejecutar en MATLAB:
Figura 3.23 Cálculo de la autocorrelación de una secuencia senoidal corrompida por ruido usando
MATLAB.
Para determinar la autocorrelación de rdd[n] se utiliza el siguiente comando en
MATLAB.
rdd= conv(d,fliplr(d));
Figura 3.24 Cálculo de la autocorrelación de rdd usando MATLAB.
78
3.3
Tercera práctica.
En esta práctica se tratan temas como la transformada discreta de Fourier, la
transformada rápida de Fourier de tiempo discreto y la DFT inversa.
A continuación se muestra la tercera práctica.
Procesamiento Digital de Señales IE-0102
Práctica #3 con SCILAB.
Transformada de Fourier de Tiempo Discreto
El siguiente programa puede emplearse para determinar los valores de la DTFT de
una secuencia real descrita como una función racional de e− j .
k = 256;
num = [0.008 -0.033 0.05 -0.033 0.008];
den = [1 2.37 2.7 1.6 0.41];
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 3_1
//Cálculo de la transformada de Fourier de tiempo discreto
// Lea la longitud deseada de la DFT
k = input('Numero de puntos de frecuencia = ');
// Lea los coeficientes del numerador y del denominador
num = input('Coeficientes del numerador = ');
den = input('Coeficientes del denominador = ');
79
// Calcule la respuesta en frecuencia
numh=poly(num,"z","coeff");
denh=poly(den,"z","coeff");
h=syslin('d',numh/denh);
[frq,bnds,split]=calfrq(h,0.001,%pi);
rf=repfreq(h,frq);
// Grafique la respuesta en frecuencia
subplot(2,2,1)
plot(frq/180,real(rf));xgrid;
title('Parte real');
xlabel('f/180');ylabel('Amplitud');
subplot(2,2,2)
plot(frq/180,-imag(rf));xgrid;
title('Parte imaginaria');
xlabel('f/180');ylabel('Amplitud');
subplot(2,2,3);
plot(frq/180,abs(rf));xgrid;
title('Espectro de magnitud');
xlabel('f/180');ylabel('Magnitud');
subplot(2,2,4);
plot(frq/180,-atand(imag(rf),real(rf))/(2*%pi));xgrid;
title('Espectro de fase');
80
xlabel('f/180');ylabel('Fase en grados');
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Los datos de entrada solicitados por el programa son el número de puntos de
frecuencia k donde la DTFT va a ser calculada y los vectores num y den que contienen los
coeficientes del numerador y del denominador de la DTFT, respectivamente,
proporcionados en orden ascendente de potencias de
e− j . Estos vectores deben ser
introducidos dentro de paréntesis cuadrados. El programa calcula los valores de la DTFT en
los puntos de frecuencia prescritos y grafica las partes real e imaginaria, junto con los
espectros de fase y magnitud. Debe notarse que debido a las relaciones de simetría de la
DTFT de una secuencia real, esta es calculada únicamente en k igualmente espaciados
valores de entre 0 y .
Como ejemplo, grafique la siguiente DTFT:
−j
− j2
− j3
− j4
0.008−0.033 e 0.05e
−0.033e
0.008 e
X e =
−j
− j2
− j3
− j4
12.37 e 2.7 e 1.6e
0.41e
j
Los datos de entrada usados para la DTFT deberían introducirse como se indica a
continuación:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
k = 256;
num = [0.008 -0.033 0.05 -0.033 0.008];
den = [1 2.37 2.7 1.6 0.41];
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
81
Cuando se grafica el espectro de fase, este muestra una discontinuidad de tamaño
2 alrededor del punto =0.72 . Esta discontinuidad puede removerse usando el
mandato unwrap. Presente tanto la fase con la discontinuidad como la fase sin ella en sus
gráficos.
Transformada Discreta de Fourier
Se va a determinar la DFT U[k] de M puntos de la siguiente secuencia de N puntos:
u [ n]=
{
1,
0,
0nN −1
para otros valores de n
}
El programa siguiente solicita los datos de entrada N y M. Para asegurar que la DFT
dé valores correctos, M debe ser mayor que o igual a N. Después que son introducidos tales
valores, calcula la DFT de M puntos y grafica la secuencia original de N puntos, junto con
la magnitud y fase de la secuencia de la DFT. Como ejemplo, use N = 8 y M = 16.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 3.2
// Ilustración del cálculo de la DFT
// N=8; M=16;
// Lea la longitud N de la secuencia y la longitud deseada M de la DFT
N = input('Introduzca la longitud de la secuencia = ');
M = input('Introduzca la longitud de la DFT = ');
// Genere la secuencia temporal de longitud N
u = [ones(1,N)];
// Calcule su DFT de M puntos
82
U = mtlb_fft(u,M);
// Grafique la secuencia temporal y su DFT
t = 0:1:N-1;
plot2d3('gnn',t,u);
title('Secuencia temporal original');
xlabel('Indice temporal n');ylabel('Amplitud');
pause
subplot(2,1,1);
k = 0:1:M-1;
plot2d3('gnn',k,abs(U));
title('Magnitud de las muestras de la DFT');
xlabel('Indice de frecuencia k');ylabel('Magnitud');
subplot(2,1,2);
plot2d3('gnn',k,atan(imag(U),real(U)) );
title('Fase de las muestras de la DFT');
xlabel('Indice de frecuencia k');ylabel('Fase');
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Se ilustra ahora el cálculo de la DFT inversa. La secuencia DFT de K puntos está
dada por:
V [ k ]=
{
k/K ,
0,
}
0k K −1
otros valores de n
83
Póngase K = 8 y N = 13 en el siguiente programa, que determina la secuencia
resultante del cálculo de la DFT inversa v[n].
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 3.3
// Ilustración del cálculo de la DFT inversa
// K=8; N=13;
// Lea la longitud K de la DFT y la longitud deseada N de la DFT inversa
K = input('Introduzca la longitud de la DFT = ');
N = input('Introduzca la longitud de la DFT inversa = ');
// Genere la secuencia DFT de longitud K
// Se trata de una rampa discreta
k = 1:K;
U = (k-1)/K;
// Calcule su DFT inversa de N puntos
u = mtlb_ifft(U,N);
// Grafique la DFT y la DFT inversa
k = 1:K;
plot2d3('gnn',k-1,U);
xlabel('Indice k de frecuencia');ylabel('Amplitud');
title('Muestras originales DFT')
pause
84
subplot(2,1,1)
n = 0:1:N-1;
plot2d3('gnn',n,real(u));
title('Parte real de las muestras temporales');
xlabel('Indice temporal n');ylabel('Amplitud');
subplot(2,1,2)
plot2d3('gnn',n,imag(u));
title('Parte imaginaria de las muestras temporales');
xlabel('Indice temporal n');ylabel('Amplitud');
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
En este último programa debe notarse que, si bien la secuencia de la DFT es real, su
DFT inversa es una secuencia temporal compleja.
Examínese ahora la siguiente secuencia:
x [n ]=cos
2r n
,
N
0nN −1,
0rN −1
Sea r = 3 y N = 16 para la secuencia de longitud finita anterior. Su DFT de 16 puntos
está entonces dada por:
{
8,
para k =3,
X [k ]= 8,
para k =13,
0, otros valores de k
}
85
Se determinará la DTFT de la secuencia x[n] de longitud 16 calculando una DFT de
512 puntos usando el siguiente programa.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 3.4
// Cálculo numérico de la DTFT usando la DFT
// Genere la secuencia sinusoidal de longitud 16
k = 0:15;
x = cos(2*%pi*k*3/16);
// Calcule su DFT de 512 puntos
X = mtlb_fft(x);
XE = mtlb_fft(x,512);
// Grafique la respuesta en frecuencia
L = 0:511;
plot(L/512,abs(XE));
mtlb_hold
plot(k/16,abs(X),'o');
xlabel('Frecuencia angular normalizada');
ylabel('Magnitud');
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
En la última figura resultante, los valores DFT X[k], mostrados por los círculos, son
precisamente las muestras de frecuencia de la DTFT en = k /8, 0k 15 .
86
Convolución lineal de dos secuencias de longitud finita
El programa siguiente determina la convolución lineal de dos secuencias de longitud
finita usando la DFT y compara el resultado obtenido usando una convolución lineal
directa. Las dos secuencias que se usarán como ejemplo son:
x [n ]={ 1 2 0 1 }
h [n]={ 2 2 1 1 }
Las dos secuencias deben introducirse en forma de vector dentro de paréntesis
cuadrados. El programa grafica el resultado de la convolución lineal obtenida usando la
DFT y la diferencia entre este resultado y la secuencia obtenida usando la convolución
directa lineal usando el mandato convol..
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 3.5
// Convolución lineal por medio de la DFT
//x=[1 2 0 1]; h=[2 2 1 1];
// Lea las dos secuencias
x = input('Introduzca la primera secuencia = ');
h = input('Introduzca la segunda secuencia = ');
// Determine la longitud del resultado de la convolución
L = length(x) + length(h) -1;
// Calcule las DFT's usando relleno de ceros
XE = mtlb_fft(x,L);
HE = mtlb_fft(h,L);
// Determine la DFT inversa del producto
87
y1 = mtlb_ifft(XE.*HE);
// Grafique la secuencia generada por la convolución basada en la DFT y el error
// obtenido al comparar este resultado y el resultado de la convolución lineal directa
k = 0:1:L-1;
subplot(2,1,1)
plot2d3('gnn',k,y1,5);
xlabel('Indice temporal n');ylabel('Amplitud');
title('Resultado de la convolución lineal basada en la DFT');
y2 = convol(x,h);
error = y1 - y2;
subplot(2,1,2);
plot2d3('gnn',k,abs(error),3)
xlabel('Indice temporal n');ylabel('Amplitud');
title('Magnitud de la secuencia de error');
//////////////////////////////////////////////////////////////////////////////////////////////////////////
88
3.3.1 Resultados de la tercera práctica.
a) Resultados del programa 3.1
Al ejecutar esta secuencia en MATLAB se obtiene:
Figura 3.25 Calculo de la DFT en MATLAB.
Figura 3.26 Calculo de la DFT en SCILAB.
89
b)
Resultados del programa 3.2
Para el programa 3.2 se obtiene en SCILAB:
Figura 3.27Secuencia temporal original en SCILAB.
Figura 3.28 Magnitud de las muestras de la DFT y fase de las muestras de la DFT en SCILAB.
90
Al ejecutar el programa en MATLAB se logro obtener las siguientes respuestas.
Figura 3.29 Secuencia temporal original en MATLAB.
Figura 3.30 Magnitud de las muestras de la DFT y fase de las muestras de la DFT en MATLAB.
91
c)
Resultados del programa 3.3
Los resultados obtenidos al ejecutar el programa en SCILAB son:
Figura 3.31 Muestras originales DFT en SCILAB.
Figura 3.32 Parte real de las muestras temporales y parte real de las muestras temporales en SCILAB.
92
Para el caso de MATLAB se obtuvo.
Figura 3.33 Muestras originales DFT en MATLAB.
Figura 3.34 Parte real de las muestras temporales y parte real de las muestras temporales en
MATLAB.
93
d)
Resultados del programa 3.4
Para SCILAB se obtiene el siguiente resultado.
Figura 3.35 Grafica de la respuesta en frecuencia en SCILAB.
Figura 3.36 Grafica de la respuesta en frecuencia en MATLAB
94
e)
Resultados del programa 3.5
Para este programa se obtiene los siguientes resultados simulados:
Figura 3.37 Convolución lineal por medio de la DFT en SCILAB.
Figura 3.38 Convolución lineal por medio de la DFT en MATLAB.
95
Al comparar la magnitud de la secuencia de error, se nota una diferencia, esta se debe
a que los valores corresponden a datos en el orden de 10 -15 por lo que son valores
sumamente pequeños y tanto MATLAB como SCILAB aproximan estos usando algoritmos
distintos. Lo anterior origina la diferencia entre ambas secuencias.
3.4
Cuarta práctica.
Para esta práctica se trata el tema de la transformada z, el calculo de la expansión de
fracciones parciales y transformada z inversa.
A continuación se muestra la cuarta práctica.
Procesamiento Digital de Señales IE-0102
Práctica #4 con SCILAB.
Transformada Z
Se solicita expresar la siguiente transformada Z en forma factorizada, graficar sus
polos y ceros y determinar sus regiones de convergencia:
4
G z =
3
2
2z 16z 44z 56z32
4
3
2
3z 3z −15z 18z−12
Para llevar a cabo la factorización, se puede usar el siguiente programa en SCILAB:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Programa 4.1;
Determinación de la forma factorizada de una transformada Z racional
num=[32 56 44 16 2]; den=[-12 18 -15 3 3];
//Para SCILAB 5.1 digite:
getf('SCI/modules/DSP/tfchk.sci');
getf('SCI/modules/DSP/tf2zp.sci');
96
[z,p,k] = mtlb_tf2zp(num,den);
m = abs(p);
disp('Los ceros están en');disp(z)
disp('Los polos están en');disp(p);
disp('Constante de ganancia');disp(k);
disp('Radios de los polos');disp(m);
//Para SCILAB 5.1 digite:
getf('SCI/modules/DSP/zp2tf.sci');
getf('SCI/modules/DSP/cplxpair.sci');
getf('SCI/modules/DSP/zp2sos.sci');
sos = mtlb_zp2sos(z,p,k);
disp('Secciones de segundo order');disp(real(sos));
h=poly(num,'z','c')/poly(den,'z','c');
plzr(h);
/////////////////////////////////////////////////////////////////////////////////////////////////////
Este último resultado se interpreta como que la forma factorizada de la transformada
Z está dada por:
−1
G z =
−2
−1
−2
0.06670.4z 0.5333z 10.020.0z 20.0z
−1
−2
−1
−2
1.02.0z −4.0z 1.0−1.0z 1.0z
16z −18z−2 12z−12z −2
=0.667
−1
−2
−1
−2
12z −4z 1−z z
Las cuatro regiones de convergencia son dadas por:
97
ℜ1 ∞≥∣z∣3.2361
ℜ2 3.2361∣z∣1.2361
ℜ3 1.2361∣z∣1
ℜ4 1∣z∣≥0
Ahora, se va a considerar la determinación de la transformada Z racional desde las
posiciones de sus ceros y polos. Los ceros son: 0.21, 3.14, -0.3 + 0.5j, -0.3 – 0.5j; los polos
están en: -0.45, 0.67, 0.81 + 0.72j, 0.81 – 0.72j; la constante de ganancia k es 2.2. El
programa SCILAB que se emplea para calcular la transformada Z racional es como sigue:
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Programa 4.2
//Determinación de la transformada Z racional desde sus polos y ceros
//format long
zr = input('Introduzca los ceros como vector fila = ');
pr = input('Introduzca los polos como vector fila = ');
// Se transpone los vectores fila de ceros y polos
//
pr=[-0.45 0.67 0.81+0.72*%i 0.81-0.72*%i];
// zr=[0.21 3.14 -0.3+0.5*%i -0.3-0.5*%i];
z = zr'; p = pr';
k = input('Introduzca la constancia de ganancia = ');
//Para SCILAB 5.1 digite:
getf('SCI/modules/DSP/zp2tf.sci');
[num,den] = mtlb_zp2tf(z,p,k);
disp('Coeficientes del polinomio del numerador');disp(num);
98
disp('Coeficientes del polinomio del denominador');disp(den);
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Los resultados deben coincidir con
4
G z =
3
2
2.2z −6.05z −2.22332z −1.63592z−0.4932312
4
3
2
z −1.84z 1.2294z 0.23004z−0.35411175
Expansión en fracciones parciales usando SCILAB
Usando SCILAB se puede determinar la expansión en fracciones parciales de una
transformada Z dada. Así por ejemplo, considérese la transformada
3
G z =
18z
3
2
18z 3z −4z−1
El siguiente programa consigue lo esperado:
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Programa 4.3
// De una transformada Z racional a la expansión en fracciones parciales
//
num = input('Introduzca los coeficientes del numerador = ');
den = input('Introduzca los coeficientes del denominador = ');
// num = [18 0 0 0]; den = [18 3 -4 -1];
getf('SCI/modules/DSP/residuez/polyval/polyval.sci');
getf('SCI/modules/DSP/residuez/deconv/deconv.sci');
99
getf('SCI/modules/DSP/residuez/polysci/polysci.sci');
getf('SCI/modules/DSP/residuez/mpoles/mpoles2.ssci');
getf('SCI/modules/DSP/residuez/meansci/meansci.sci');
getf('SCI/modules/DSP/residuez/residuez.sci');
[r,p,k] = residuez(num,den);
disp('Residuos'); disp(r')
disp('Polos');disp(p')
disp('Constantes');disp(k)
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Hay que recordar que los coeficientes deben introducirse usando paréntesis
cuadrados, como se indica a continuación:
num = [18 0 0 0];
den = [18 3 -4 -1];
Los datos de salida son los residuos, las constantes (si las hay) y los polos de la
expansión de G(z). Para nuestro ejemplo,
Residuos: 0.36, 0.24, 0.4
Polos: 0.5, -0.3333, -0.3333
Constantes: ninguna en este caso
Nótese que la transformada Z de nuestro ejemplo tiene un polo doble en z = -1/3 =
-0.3333. Los resultados son interpretados de la siguiente manera:
G z =
0.36
0.24
0.4
−1
−1
1−0.5z
10.3333z
10.3333z−1 2
100
Si se desea hacer el procedimiento inverso, en donde se comenzara con una
descripción de G(z) como la dada arriba, entonces se podría usar el siguiente programa en
SCILAB:
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Programa 4.4
//De la expansión en fracciones parciales a la transformada Z racional
r = input('Introduzca los residuos = ');
p = input('Introduzca los polos = ');
k = input('Introduzca las constantes = ');
// r= [0.4 0.24 0.36];p = [-0.3333 -0.3333 0.5];k = [0];
getf('SCI/modules/DSP/residuez/mpoles/mpoles.sci');
getf('SCI/modules/DSP/residuez/polysci/polysci.sci');
getf('SCI/modules/DSP/residuezinv/residuezinv2.sci');
[num,den] = residuezinv2(r,p,k)
disp('Coeficientes del polinomio del numerador');disp(num)
disp('Coeficientes del polinomio del denominador');disp(den)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Los datos que se solicitan en el programa anterior deben introducirse usando
paréntesis cuadrados:
r = [0.4 0.24 0.36]
101
p = [-0.3333 -0.3333 0.5]
k = [0]
Véase que es importante el orden en que se introducen los valores, pues deben
corresponder a la representación que se se hace de los polos dobles y simples. El programa
da como salida los coeficientes del numerador y del denominador, en potencias
descendientes de z. Los coeficientes son exactamente los mismos si se multiplica cada
coeficiente por 18.
Coeficientes del polinomio del numerador
1.0000
0.0533 -0.0267
0
Coeficientes del polinomio del denominador
1.0000
0.1666 -0.2222 -0.0555
Transformada inversa Z
La inversa de la transformada Z racional puede también calcularse usando MATLAB.
El mandato impz puede utilizarse para este propósito.
[h,t] = impz(num,den.L)
Los datos de entrada consisten de los vectores num y den que contienen los
coeficientes de los polinomios del numerador y del denominador dados en potencias
descendientes de z. La salida es el vector de la respuesta al impulso h y el vector t que hace
de índice temporal. En el primer mandato, la longitud L de h es determinada
102
automáticamente por el computador con t = 0:L-1, en tanto que en los dos mandatos
restantes el usuario la proporciona. En el último mandato, el intervalo de tiempo es
escalado de modo que el intervalo de muestreo es igual al recíproco de la función de
transferencia. El valor supuesto de la función de transferencia es 1.
Otra manera de llegar al resultado es mediante el uso del mandato filter:
y = filter(num,den,x)
donde y es el vector de salida que contiene los coeficientes de la representación en
series de potencias de H(z) expresado en potencias negativas ascendientes de z. Los
coeficientes del numerador y denominador de H(z) expresados en potencias ascendientes
negativas de z son dos de los vectores de datos de entrada num y den. La longitud de x es la
misma que la de y, y todos sus elementos son cero excepto por el primero que es igual a 1.
Se presenta dos programas a continuación para ilustrar el uso de los mandatos
anteriores.
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Programa 4.5
// Expansión en series de potencias de una transformada Z racional
//
// Introduzca el número de coeficientes de transformada Z inversa a ser calculados
L = input('Introduzca la longitud del vector de salida = ');
// Lea los coeficientes del numerador y del denominador de la transformada Z
num = input('Introduzca los coeficientes del numerador = ');
den = input('Introduzca los coeficientes del denominador = ');
103
// Calcule el número deseado de coeficientes de la transformada inversa
//Solución 1
x = [1 zeros(1,L-1)];
y = filter(num,den,x);
disp('Coeficientes de la expansion en series de potencias');
disp(y)
//Solución 2
k = 0:1:L-1;
t=k';
getf('SCI/modules/DSP/impz/impz.sci');
[y,t]=impz(num,den,L)
disp('Coeficientes de la expansion en series de potencias');
disp(y)
///////////////////////////////////////////////////////////////////////////////////////////////////////
Los datos de entrada llamados por el programa son el número deseado de coeficientes
y los vectores de los coeficientes del numerador y del denominador de la transformada Z
racional, con estos últimos introducidos dentro de paréntesis cuadrados. Para nuestro
ejemplo,
L = 11;
num = [1
2];
den = [1 0.4
-0.12];
104
Los datos de salida son los coeficientes deseados de la transformada Z inversa que
deben aparecer como:
1.0000 1.6000 -0.5200 0.4000 -0.2224 0.1370 -0.0815 0.0490 -0.0294 0.0176 0.0106
Este resultado se puede chequear usando división sintética.
A continuación se ofrece un programa para determinar la transformada Z inversa pero
usando el mandato filter:
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Programa 4.6
// Expansión en series de potencias de una transformada Z racional
//
// Introduzca el número de coefficientes de la transformada Z inversa a calcularse
N = input('Introduzca la longitud del vector de salida = '); // N=5;
// Introduzca los coeficientes del numerador y del denominador de la transformada Z
num = input('Introduzca los coeficientes del numerador = '); // num = [1
2];
den = input('Introduzca los coeficientes del denominador = ');// den = [10.4 -0.12];
// Calcule el número deseado de coeficientes de la transformada inversa
x = [1
zeros(1,N-1)];
y = filter(num,den,x);
disp('Coeficientes de la expansión en series de potencias');
disp(y)
105
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
El programa anterior pregunta por la longitud deseada del vector de salida y (ponga N
= 5) y se le introduce también los vectores que contienen los coeficientes del numerador y
del denominador dentro de paréntesis cuadrados y en potencias descendientes positivas de
z. Después de calcular el vector de salida, muestra sus elementos que son los coeficientes
de la expansión en series de potencias de la transformada Z racional. El programa supone
que la transformada Z es una fracción propia con el polinomio del denominador con un
orden mayor que el del numerador.
Usando los valores para num y den del ejemplo inmediato anterior, la salida es la
siguiente: 0.0962
3.4,1
a)
0.1934
0.0022
0.0000
0.0000
Resultados de la cuarta práctica
Resultados del programa 4.1
Los resultados al ejecutar esta parte de la práctica en MATLAB son:
Resultados:
Los ceros estan en:
-4.0000-2.0000
-1.0000 + 1.0000i -1.0000 - 1.0000i
Los polos estan en:
-3.2361
1.2361
Constante de ganancia
0.6667
Radios de los polos
0.5000 + 0.8660i
0.5000 - 0.8660i
106
3.2361
1.2361
1.0000 1.0000
Figura 3.38 Polos y ceros en el plano Z obtenidos en MATLAB.
Al ejecutar en SCILAB se obtiene:
Los ceros estan en
- 4.
- 2.
- 1. + i
- 1. - i
Los polos estan en
- 3.236068
1.236068
0.5 + 0.8660254i
0.5 - 0.8660254i
Constante de ganancia
0.6666667
Radios de los polos
3.236068
1.236068
1.
1.
107
Figura 3.39 Polos y ceros en el plano Z obtenidos en SCILAB.
b)
Resultados del programa 4.2
Resultados obtenidos en MATLAB y SCILAB son:
Resultados:
Coeficientes del polinomio del numerador
2.2000 -6.0500 -2.2233 -1.6354
0.4932
Coeficientes del polinomio del denominador
1.0000 -1.8400
c)
1.2294
0.2300 -0.3541
Resultados del programa 4.3
Resultados obtenidos con Matllab.
Residuos
0.3600
0.2400
0.4000
Polos
0.5000 -0.3333 -0.3333
108
Constantes
0
Resultados elaborados con MATLAB.
d)
Resultados del programa 4.4
Coeficientes del polinomio del numerador
1.0000
0.0533 -0.0267
0
Coeficientes del polinomio del denominador
1.0000
0.1666 -0.2222 -0.0555
e)
Resultados del programa 4.5
y= 1. 1.6 - 0.52
0.0176374 - 0.0105813
f)
0.4 - 0.2224
0.13696 - 0.081472
Resultados del programa 4.6
Tanto con SCILAB como con MATLAB el resultado es:
0.0962
0.1934
0.0022
0.0000
0.0000
0.049024 - 0.0293862
109
3.5
En
Quinta práctica
esta práctica se trata el tema de muestreo y conversión digital analógica, el traslape
y la interpolación y decimación.
A continuación se muestra la quinta práctica.
Procesamiento Digital de Señales IE-0102
Práctica #5 con SCILAB.
Parte A: Muestreo y Conversión Digital/Analógica
Se simulará el muestreo de señales de tiempo continuo o analógicas para producir
señales de tiempo discreto. Puesto que SCILAB sólo puede procesar señales de tiempo
discreto (vectores), no se puede utilizar realmente señales analógicas sin el uso de
dispositivos externos de conversión analógico/digitales (A/D). En su lugar, por
consiguiente, se simulará el muestreo analógico mediante el muestreo de las secuencias de
tiempo discreto correspondientes, que se conoce como decimación de las secuencias.
Recíprocamente, se simulará la conversión digital-analógica (D/A)
mediante la
interpolación de secuencias de tiempo discreto. La interpolación y la decimación son
operaciones bastante útiles, aparte de su uso en la simulación de las conversiones A/D y
D/A.
Para generar un tren de impulsos de tiempo discreto para su empleo en muestreo, se
obtiene la respuesta al impulso del filtro peine H(z) = 1/(1 - z-4), como sigue:
a = [1 0 0 0 -1];
110
d = [1 zeros(1,127)];
train = filter(1,a,d);
n = 0:127;
//Grafíquese el vector train contra el vector n.
plot(n,train);
Genérese también una señal coseno con 32 muestras por ciclo mediante
x = cos(2*%pi*n/32);
El espectro correspondiente sobre el intervalo de Nyquist normalizado (-1,1) se
obtiene entonces como.
s=1; nfft =128;b=x;a=1;
nb = length(b);
na = length(a);
a = [a zeros(1,nb-na)];
b = [b zeros(1,na-nb)];
n = length(a);
h = (mtlb_fft(b,s*nfft)./mtlb_fft(a,s*nfft)).';
h = h(1:nfft);
h = h(:);
hh = h;
deltaF = (2*%pi)/nfft;
w = linspace(0,2*%pi-deltaF,nfft);
w = w(:);
111
wp = mtlb_fftshift(w)/%pi -1;
plot(wp,hh);
Otra alternativa es usar la función generada para esta aplicación:
n = 0:127;
x = cos(2*%pi*n/32);
getf('SCI/modules/DSP/freqz/freqz.sci');
[hh,w]=freqz(x,1,128,1);
wp = mtlb_fftshift(w)/%pi -1;
plot(wp,real(abs(hh)));
Por comparación, también ejecútese el comando plot(w,hh).
Nótese que los impulsos tienen forma triangular en estos gráficos. (El espectro es real
porque una señal coseno es par). Simúlese muestrear la señal coseno con ocho muestras por
ciclo multiplicándola (elemento por elemento) por el tren de impulsos, es decir,
n = 0:127;
a = [1 0 0 0 -1];
d = [1 zeros(1,127)];
train = filter(1,a,d);
x = cos(2*%pi*n/32);
y = x.*train;
M=8;
112
yy=intdec(y,M/32);
nn=[0:length(yy)-1];
plot2d3('gnn',nn,yy-3);
Para que pueda compara grafique
plot(n,y);
Grafíquese la señal muestreada yy y su espectro asociado como se hizo anteriormente
para la señal “hh”. Nótese las imágenes espectrales alrededor de cada múltiplo de la nueva
razón de muestreo (normalizada, wp = 0.5). Dado que la señal coseno es perfectamente de
banda limitada y se satisface el teorema del muestreo, no se ha producido ningún
“aliasing”.
Para estudiar las propiedades espectrales de un convertidor D/A, simúlese su
respuesta al impulso efectiva y su respuesta de magnitud mediante:
h = ones(1,4);
H = mtlb_fft(h,128);
plot(mtlb_fftshift(wp),mtlb_fftshift(abs(H)));mtlb_hold;
Aplicando este filtro D/A a la señal muestreada “y”, se obtiene en el dominio del
tiempo
yd = filter(h,1,y);
plot(n,yd);plot(n,x)
y en el dominio de la frecuencia
Yd = mtlb_fft(yd);
plot(wp,abs(Yd));mtlb_hold;
113
Explíquese los componentes espectrales residuales alrededor de las frecuencias ±0.5 y
±1.
Para aplicar un postfiltro ideal con una frecuencia de corte de un octavo la frecuencia
de muestreo a la salida del convertidor D/A, ejecútese los siguientes mandatos:
Yc = Yd;Yc(17:112) = zeros([0:95]);
plot(wp,abs(Yc));xgrid;
yc = mtlb_ifft(Yc);
plot(n,yc,n,x);mtlb_hold;
Nótese el ligero desplazamiento de fase y la atenuación en la amplitud en la salida del
postfiltro “yc” contra la señal original “x” causada por el convertidor D/A.
Parte B: Traslape (“Aliasing”)
Para un primer ejemplo de una señal no bandalimitada y el “aliasing” resultante
después del muestreo, se utilizará una señal de onda cuadrada. Para sintetizar ocho ciclos de
una onda cuadrada de tiempo discreto y para simular su espectro de magnitud DTFT, se
hace:
n = 0:127;
x = cos(2*%pi*n*8/128 + 0.01);
y = sign(x);
El pequeño desplazamiento de fase (0.01) asegura un signo correcto.
plot2d3('gnn',n,y);
b=y;a=1;s=2; nfft =64;
nb = length(b);
114
na = length(a);
a = [a zeros(1,nb-na)];
b = [b zeros(1,na-nb)];
n = length(a);
h = (mtlb_fft(b,s*nfft)./mtlb_fft(a,s*nfft)).';
h = h(1:nfft);
h = h(:);
hh = h;
deltaF = %pi/nfft;
w = linspace(0,%pi-deltaF,nfft);
w = w(:);
mag = abs(hh);
plot(w,mag);
Nótese que la onda cuadrada tiene sólo armónicas impares, que decaen de la forma 1/
k (pero no tan exactamente, pues las armónicas superiores para k = 9, 11, 13, … caen
encima de las correspondientes para k = 1, 3, 5, 7). Para producir casos donde el “aliasing”
de las armónicas superiores no se disfrace de esta manera, sintetice una onda cuadrada con
12 ciclos sobre 128 muestras, y otra con 11 ciclos, y grafíquese sus espectros de magnitud
como anteriormente se hizo.
Genérese ahora una secuencia exponencial causal y su espectro de magnitud mediante
n=0:127;
115
x = exp(-n/5);
b=x;a=1;s=2; nfft =64;
nb = length(b);
na = length(a);
a = [a zeros(1,nb-na)];
b = [b zeros(1,na-nb)];
n = length(a);
h = (mtlb_fft(b,s*nfft)./mtlb_fft(a,s*nfft)).';
h = h(1:nfft);
h = h(:);
hh = h;
deltaF = %pi/nfft;
w = linspace(0,%pi-deltaF,nfft);
w = w(:);
magX = abs(hh);
plot(w,magX);
Muestrée el exponencial a un cuarto de la razón de muestreo original usando el tren
de impulsos train de la parte A, es decir,
a = [1 0 0 0 -1];
d = [1 zeros(1,127)];
train = filter(1,a,d);
y = x.*train;
116
Para computar el espectro correspondiente y para compararlo con el del exponencial
original (después de un escalamiento adecuado), se ejecuta los mandatos,
b=x;a=1;s=2; nfft =64;
nb = length(b);
na = length(a);
a = [a zeros(1,nb-na)];
b = [b zeros(1,na-nb)];
n = length(a);
h = (mtlb_fft(b,s*nfft)./mtlb_fft(a,s*nfft)).';
h = h(1:nfft);
h = h(:);
hh = h;
deltaF = %pi/nfft;
w = linspace(0,%pi-deltaF,nfft);
w = w(:);
magX = abs(hh);
by=y;ay=1;sy=2; nffty =64;
nby = length(by);
nay = length(ay);
ay = [ay zeros(1,nby-nay)];
by = [by zeros(1,nay-nby)];
ny = length(ay);
117
yy = (mtlb_fft(by,sy*nffty)./mtlb_fft(ay,sy*nffty)).';
yy = yy(1:nffty);
yy = yy(:);
Y = yy;
deltaF = %pi/nfft;
w = linspace(0,%pi-deltaF,nfft);
w = w(:);
magY = abs(Y);
magY = magY*magX(1)/magY(1);
plot(w,magX,w,magY);
Nótese el efecto del “aliasing”. Simúlese ahora el efecto de la conversión D/A como
en la parte A, y compárese el espectro de salida asociado con los espectros precedentes para
x e y.
Parte C: Interpolación y decimación
Se puede interpolar o decimar secuencias usando los mandatos interp y decimate
(individualmente o en combinación para cambiar la razón de muestreo por un factor
racional L/K), o el único comando resample. Por ejemplo, considérese la siguiente
interpolación de un senoide por L=4:
x = linspace(0,39,10)';
y = cos(2*%pi*x/5);
dk = splin(x,y);
xx = linspace(0,39,40)';
118
[yyk, yy1k, yy2k] = interp(xx, x, y, dk);
plot2d(xx, [yyk])
plot2d(x, y, -9)
Compare los valores interpolados yyk con los valores ideales xi. ¿Dónde ocurre la
mayor desviación? Un despliegue en el dominio de la frecuencia del error de interpolación
es proporcionado por
Y = mtlb_fft(yyk);
plot2d(m,abs(Y),2);mtlb_hold;
¿Cómo deberían de ser estos valores de la FFT? (Recuérdese que la FFT es un
algoritmo rápido para calcular la transformada de Fourier). Repita el experimento anterior
para
y = sin(2*%pi*x/5);
y también para las secuencias impulso
y = zeros(1,10);y(5) = 1;
y = zeros(1,10);y(10) = 1;
Nótese las respuestas al impulso y de frecuencia (variantes con el tiempo) del filtro
interpolador.
Ahora inviértase el experimento para chequear la decimación, o sea,
m = 0:39; n = 0:9;
xi = cos(2*%pi*m/20);
xii = cos(2*%pi*m/20-5.43);
//el 5,43 es debido a un desfase originado por la función intdec de scilab.
119
yy=intdec(xii,1/4);
plot2d(4*n+3,yy,-3);plot(m,xi);
Nótese que con los desplazamientos de tiempo apropiados, como el dado, la
decimación ejecutada sobre este senoide es casi perfecta. Empero, repítase el experimento
para otras frecuencias tales como
xi = cos(4*%pi*m/20);
xi = cos(2.5*%pi*m/20);
3.5.1 Resultados de la quinta práctica.
a)
Resultados de la parte A.
Al ejecutar esta parte de la sexta práctica en MATLAB se obtine:
Figura 3.40 Tren de pulsos en MATLAB y SCILAB.
120
Figura 3.41 Espectro correspondiente sobre el intervalo de Nyquist normalizado (-1,1) en
MATLAB y SCILAB.
Figura 3.42 Señal coseno con ocho muestras por ciclo multiplicándola (elemento por elemento) por el
tren de impulsos.
121
Figura 3.43 Respuesta al impulso efectiva y su respuesta de magnitud en MATLAB y SCILAB.
Figura 3.44 Señal en el dominio del tiempo obtenida con MATLAB y SCILAB.
122
Figura 3.45 Señal en el dominio de la frecuencia obtenida con MATLAB y SCILAB.
Figura 3.46 Señales para
aplicar un postfiltro en MATLAB y SCILAB.
123
Figura 3.47 Respuesta en el tiempo al aplicar FFT en
b)
MATLAB y SCILAB.
Resultados de la parte B
Ejecutando en MATLAB obtenemos:
Figura 3.48 Primer ejemplo de aliasing en MATLAB y SCILAB.
124
Figura 3.49 Respuesta de FFT MATLAB y SCILAB.
Figura 3.50 Secuencia exponencial causal en MATLAB y SCILAB.
125
Figura 3.51 Espectro de frecuencia y señal original en MATLAB y SCILAB.
c)
Resultados de la parte C
Figura 3.52 Interpolación de un senoide por L = 4
126
Figura 3.53 Despliegue
en el dominio de la frecuencia del error en MATLAB y
SCILAB.
Figura 3.54 Chequeo de decimación en MATLAB y SCILAB.
127
3.6
Sexta práctica
A continuación se presenta la sexta práctica.
Procesamiento Digital de Señales IE-0102
Práctica #6 con SCILAB.
Técnica de relleno con ceros y de enventanado.
Parte A: Técnica de rellenado con ceros.
El relleno con ceros es la operación de extender una secuencia de longitud N 1 a una
de longitud N2 > N1 mediante el agregado de (N2 - N1) muestras cero a la secuencia inicial.
Esto se hace por dos razones: (1) para convertir la convolución circular en convolución
lineal (en el dominio del tiempo) o, (2) para interpolar entre las N 1 muestras de la DFT (en
el dominio de la frecuencia). Para demostrar el primero de estos efectos, sintetice un pulso
coseno de longitud 40 mediante los mandatos
n = [0:39];
x = cos(2*%pi*4*n/40);
Calcule ahora su DFT usando el algoritmo de la FFT escribiendo
X = mtlb_fft(x,64);
Al especificar una FFT de 64 puntos se hace que el pulso de 40 muestras sea
rellenado con ceros hasta una longitud de 64 puntos antes de calcular la DFT.
Convoluciónese el pulso consigo mismo elevando al cuadrado cada elemento de su DFT
para luego sacar la transformada inversa de la siguiente manera:
Y = X.^2;
128
y =mtlb_ifft(Y);
n = [0:63];
f0=scf(0);clf;
plot(n,real(y),-3);mtlb_hold;
mtlb_axis([min(n) max(n) min(real(y)) max(real(y))]);
xlabel('Indice n');
ylabel('Funcion resultante');
title('Efectos de la convolucion circular');
El mandato real(y) se utiliza para tomar la parte real de la secuencia y, pues en
general, tal secuencia es compleja. En este caso, la parte compleja es infinitesimal, por lo
que puede despreciarse sin problema. El mandato mtlb_axis se utiliza para encuadrar bien
la curva dentro del marco de la figura. Nótese que la porción inicial de la señal resultante
está distorsionada por los efectos de traslape y de enrollamiento de la convolución circular.
Para evitar esto, se debe incrementar el relleno con ceros hasta por lo menos completar 80
muestras, después de lo cual podemos calcular, elevar al cuadrado y sacar la transformada
inversa de la DFT para realizar la convolución lineal. Hágase esto de la siguiente forma:
X1 = mtlb_fft(x,80);
Y1 = X1.^2;
y1 = mtlb_ifft(Y1);
n1 = [0:79];
f1=scf(1);clf;
scf(f1);
129
plot2d(n,real(y),1)
plot2d(n1,real(y1),2);mtlb_hold;
xlabel('Indice n');
ylabel('Convolucion circular y relleno con ceros');
title('Efectos del relleno con ceros');
Un resultado equivalente puede obtenerse usando el mandato y = convol(x,x) pero
la convolución rápida usando el mandato FFT reduce sustancialmente el tiempo de cálculo
requerido.
Para demostrar el efecto espectral del relleno con ceros, sintetice tres ciclos de una
señal coseno con base en 32 muestras, con y sin relleno con ceros a una longitud de T
puntos:
T = 256;
// T: tamaño del vector rellenado con ceros
n = [0:31];
x = cos(2*%pi*3*n/(max(n)+1));
x1 = [x zeros(1,T-(max(n)+1))];
n1 = [0:(T-1)];
Calcule y grafique las correspondientes magnitudes de la DFT con y sin relleno con
ceros ejecutando los mandatos:
mag = abs(mtlb_fft(x));
mag1 = abs(mtlb_fft(x1));
130
n2 = (T/(max(n)+1))*n;
f2=scf(2);clf;
scf(f2);
plot2d(n1,mag1,3); plot2d(n2,mag,5);mtlb_hold;
alto = max([max(mag1) max(mag)]);
bajo = min([min(mag1) min(mag)]);
mtlb_axis([min(n1) max(n1) bajo alto]);
Repita el procedimiento seguido para la señal coseno inmediata anterior para la señal
y = cos(2*%pi*3.25*n/(max(n)+1));
y note la diferencia entre las DFTs de 32 puntos de la señal coseno original y esta
última. Haga comentarios en el sentido de justificar cualquier discrepancia.
y1 = [y zeros(1,T-(max(n)+1))];
magy = abs(mtlb_fft(y));
magy1 = abs(mtlb_fft(y1));
f3=scf(3);clf;
scf(3);
plot2d(n1,magy1,6);plot2d(n2,magy,-3);mtlb_hold;
alto = max([max(magy1) max(magy)]);
bajo = min([min(magy1) min(magy)]);
mtlb_axis([min(n1) max(n1) bajo alto]);
131
Parte B: Técnica de enventanado
La ventana rectangular implícita en la transformada discreta de Fourier tiene lóbulos
secundarios que están a lo menos 13 decibelios por debajo del lóbulo principal y que
decaen con una pendiente de 6 dB/octava. La ventana von Hann (Hanning), por otro lado,
tiene lóbulos secundarios por debajo de 31 decibelios del lóbulo principal y una pendiente
de caída de 18 dB/octava, mientras que la ventana Blackman tiene lóbulos secundarios por
debajo de 57 decibelios, con una pendiente de caída similar a la ventana von Hann, de
donde las señales pequeñas son más fáciles de detectar en la presencia de señales grandes
usando las ventanas Blackman o von Hann que con la ventana rectangular. Esto se consigue
al precio de una pérdida de resolución espectral para señales muy cercanas entre sí al
emplearse ventanas distintas de la rectangular. Recuérdese que la resolución tiene que ver
con el ancho del lóbulo principal de una ventana: al emplearse una ventana con un lóbulo
principal angosto, se obtiene una mayor resolución; de lo contrario, disminuye la
resolución.
Por ejemplo, genérese una señal con dos senoides,
N = 127;
n = [0:N];
x = sin(2*%pi*4.5*n/(N+1)) + cos(2*%pi*6.5*n/(N+1));
f1=scf(1);clf;
scf(1);
plot(n,x);mtlb_hold;
mtlb_axis([min(n) max(n) min(x) max(x)]);
132
xlabel('Indice n');
ylabel('Funcion');
title('Dos senoides juntos');
Aplíquese las ventanas von Hann y Blackman a la secuencia (realizando una
multiplicación elemento por elemento) mediante los mandatos siguientes y grafíquese los
resultados:
w=window('hn',N+1)
w1=w';
xh = x.*w1';
w2=window('kr',N+1,8.6);
w3=w2';
xb = x.*w2;
f2=scf(2);clf;
plot2d(n,xh,);
plot2d(n,xb,3);
mtlb_axis([min(n) max(n) min(xh) max(xh)]);
xlabel('Indice n (Magenta: von Hann, azul: Blackman)');
ylabel('Funcion enventanada');
title('Efecto de ventanas von Hann y Blackman');
133
Las ventanas se utilizan con la intención de eliminar el efecto de la longitud finita de
las secuencias sobre el espectro. Tal efecto se manifiesta con la dispersión espectral
(leakage en inglés).
Calcúlese y grafíquese ahora el espectro de magnitud correspondiente en decibelios
para la ventana von Hann y para la Blackman usando los mandatos:
Xh = mtlb_fft(xh);
dbh = 20*log10(abs(Xh));
dbh = dbh - max(dbh);
f3=scf(3);clf;
scf(3);
plot2d(n,dbh,3);mtlb_hold;
mtlb_axis([min(n) max(n) min(dbh) max(dbh)]);
xlabel('Indice n');
ylabel('Espectro');
title('Espectro con ventana von Hann');
Xb = mtlb_fft(xb);
dbb = 20*log10(abs(Xb));
dbb = dbb - max(dbb);
f4=scf(4);clf;
scf(4);
plot2d(n,dbb,2);mtlb_hold;
134
mtlb_axis([min(n) max(n) min(dbb) max(dbb)]);
xlabel('Indice n');
ylabel('Espectro');
title('Espectro con ventana Blackman');
En ambos espectros debiera aparecer los dos componentes senoidales. Si no son
distinguibles, explique la razón. Procédase ahora a rellenar las secuencias xh y xb con
ceros, recalcúlese ambos espectros y verifíquese si se distinguen los dos componentes
senoidales.
L = 4*(N+1);
// L: hasta donde se completa con ceros
xh = [xh zeros(1,L-(N+1))];
xb = [xb zeros(1,L-(N+1))];
n = [0:4*(N+1)-1];
Xh = mtlb_fft(xh);
dbh = 20*log10(abs(Xh));
dbh = dbh - max(dbh);
f5=scf(5);clf;
scf(5);
plot2d(n,dbh,3);mtlb_hold;
mtlb_axis([min(n) max(n) min(dbh) max(dbh)]);
xlabel('Indice n');
ylabel('Espectro de secuencia rellenada con ceros');
135
title('Espectro con ventana von Hann');
Xb = mtlb_fft(xb);
dbb = 20*log10(abs(Xb));
dbb = dbb - max(dbb);
f6=scf(6);clf;
scf(6);
plot2d(n,dbb,6);mtlb_hold;
mtlb_axis([min(n) max(n) min(dbb) max(dbb)]);
xlabel('Indice n');
ylabel('Espectro de secuencia rellenada con ceros');
title('Espectro con ventana Blackman');
Para examinar el ámbito dinámico de las dos ventanas anteriores para este ejemplo, es
decir, su capacidad para distinguir componentes espectrales débiles y cercanos entre sí,
genérese una señal multisenoidal de la forma siguiente:
N = 127;
n = [0:N];
arg = 2*%pi*n/(N+1);
x = sin(10*arg) + 0.001*(cos(15*arg) + sin(20*arg) + cos(25*arg));
f7=scf(7);clf;
scf(7);
plot2d(n,x,4);mtlb_hold;
136
mtlb_axis([min(n) max(n) min(x) max(x)]);
xlabel('Indice n');
ylabel('Funcion multisenoidal');
title('Funcion con cuatro senoides');
El indicador k dentro del mandato plot indica que se debe usar el color negro. Si su
versión de SCILAB no lo tiene, utilice otro indicador de color. Utilícese ahora ventanas
von Hann y Blackman y aplíquense sobre la secuencia:
w=window('hn',N+1);
w1=w';
xh = x.*w1';
w2=window('kr',N+1,8.6);
w3=w2';
xb = x.*w2;
Ahora, rellénense las dos secuencias con ceros, calcúlense y grafíquense los espectros
de magnitud correspondientes en decibelios. Verifíquese cuáles de los cuatro senoides
pueden distinguirse en los espectros y cuál de las dos ventanas para este ejemplo da
mejores resultados.
L = 4*(N+1);
xh = [xh zeros(1,L-(N+1))];
xb = [xb zeros(1,L-(N+1))];
n = [0:4*(N+1)-1];
Xh = mtlb_fft(xh);
137
dbh = 20*log10(abs(Xh));
dbh = dbh - max(dbh);
f8=scf(8);clf;
scf(8)
plot2d(n,dbh,3);mtlb_hold;
mtlb_axis([min(n) max(n) min(dbh) max(dbh)]);
xlabel('Indice n');
ylabel('Espectro de secuencia rellenada con ceros');
title('Espectro de secuencia enventanada con ventana von Hann');
Xb = mtlb_fft(xb);
dbb = 20*log10(abs(Xb));
dbb = dbb - max(dbb);
f9=scf(9);clf;
scf(9);
plot2d(n,dbb,6);mtlb_hold;
mtlb_axis([min(n) max(n) min(dbb) max(dbb)]);
xlabel('Indice n');
ylabel('Espectro de secuencia rellenada con ceros');
title('Espectro de secuencia enventanada con ventana Blackman');
Es interesante a esta altura del análisis apreciar el efecto amortiguador que tienen las
ventanas sobre el fenómeno de la dispersión. Para visualizar tal efecto, ejecútense los
siguientes mandatos y realícese un comentario sobre los resultados. Fundamentalmente, los
138
mandatos que a continuación se proponen realizan una comparación entre la ventana
rectangular y las dos ventanas estudiadas en esta práctica.
x = [x zeros(1,L-(N+1))];
n = [0:4*(N+1)-1];
X = mtlb_fft(x);
dbr = 20*log10(abs(X));
dbr = dbr - max(dbr);
f10=scf(10);clf;
scf(10);
plot2d(n,dbr,1);
plot2d(n,dbh,3);
mtlb_axis([min(n) max(n) min(dbh) max(dbh)]);
xlabel('Indice n (secuencias rellenadas con ceros)');
ylabel('Comparacion de espectros');
title('Efectos de ventanas rectangular y von Hann');
f11=scf(11);clf;
scf(11);
plot2d(n,dbr,5);
plot2d(n,dbb,9);mtlb_hold;
mtlb_axis([min(n) max(n) min(dbb) max(dbb)]);
xlabel('Indice n (secuencias rellenadas con ceros)');
ylabel('Comparacion de espectros');
139
title('Efectos de ventanas rectangular y Blackman');
Nota: Es siempre posible mejorar esta práctica, especialmente en lo que concierne a
utilizar una mejor programación que la propuesta para conseguir los mismos resultados.
Como estudiante, siéntase libre para usar su creatividad.
3.6.1
a)
Resultados de la sexta práctica.
Resultados de la parte A
La siguiente figura muestra a la izquierda la simulación en SCILAB y a la derecha la
simulación en MATLAB.
Figura 3.55 Efectos de la convolución circular.
Figura 3.56 Convolucion circular y rellenos con ceros.
140
Figura 3.57 Magnitudes de la DFT con y sin relleno.
Figura 3.58 Resultados de las ventanas von Hann y Blackman en señal generada con dos senoides.
141
b)
Resultados de la parte B
Figura 3.60 Espectro de magnitud correspondiente en decibelios para la ventana von Hann y para la
Blackman.
142
Figura 3.62 Efectos de la ventana rectangular y Von Hann y rectangular con ventana de
Blackman.
3.7
En
Sétima práctica
esta práctica se da la modificación de un archivo de audio tipo wav aplicando
filtros digitales, lo que permite generar efectos de reverberación, eco, etc.
A continuación se muestra la séptima práctica en SCILAB.
Procesamiento Digital de Señales IE-0102
Práctica #7 con SCILAB.
Procesamiento de señales de audio.
Entre las funciones de SCILAB están las funciones “loadwave” y “wavread” que
permiten cargar un archivo de audio “.wav”.
143
En la carpeta “DSP/wavfile” se encuentra un archivo llamado DSP.wav, cargue este
archivo de las siguiente forma:
--> x=wavread(path); //El path es la dirección del directorio raíz donde esta el archivo
// para estudiantes que utilizan SCILAB-5.1 y copiaron la carpeta DSP en la carpeta
modules
// dentro del directorio de SCILAB en archivos de programas pueden utilizar
--> x=wavread('SCI/modules/DSP/wavfile/DSP.wav');
//donde el path sería path = 'SCI/modules/DSP/wavfile/DSP.wav
Con esto se abre el archivo DSP.wav en el directorio C:\Archivos de programa\scilab5.1.1\modules\DSP\wavfile\DSP.wav
También puede utilizar:
--> x=loadwave('path') // Las comillas indican que la entrada es un string
Ahora podemos escuchar el archivo cargado tecleando.
--> [a]=playsnd(x);
Eco y reverberación
Frecuentemente se utilizan filtros digitales para el procesamiento de señales de audio,
esto con el objetivo de crear efectos especiales. Dos de estos efectos son el eco y la
reverberación.
Un filtro de eco puede presentar el siguiente diagrama.
144
Figura 3.63 Filtro de eco simple.
Para este diagrama la ecuación de diferencias será
y [n]=x [n ] x [n−D]
Para generar un efecto de eco en nuestra señal de audio digite lo siguiente:
//Reverberador multieco
//Generando
efecto de multieco
d=loadwave('SCI/modules/DSP/wavfile/DSP.wav');
a=length(d)/2;
a=round(a)-10;
for i=1:a-1;
b=d(1,i);
y(i)=b;
end
f=length(y)/2;
y1=y(1:f); y2=y(f+1:length(y));
num=[0,zeros(1,2000),1];
den=[1,zeros(1,2000),-0.8];
stacksize('max');
x1=filter(num,den,y1); x2=filter(num,den,y2); //Durara varios minutos
r=length(x1); // igual al ancho de x2
145
x=x1;
for i=r+1:r*2-1
x(i)=x2(i-r);
end
savewave('SCI/modules/DSP/wavfile/Multieco.wav',x);
Ahora podemos escuchar nuestro efecto de audio que fue generado y guardado en la
carpeta indicada por el path en la función “savewave”. La respuesta impulsional típica de
este tipo de filtros se muestra a continuación.
//Respuesta impulsional típica
I =[1,zeros(1,60)];
numi=[0,zeros(1,10),1];
deni=[1,zeros(1,10),-0.8];
d2= filter(numi,deni,I);
plot2d3('gnn',d2); plot2d([1:length(d2)],d2,-9);
xlabel('Índice de muestreo');
ylabel('Amplitud');
title(['Respuesta impulsional típica']);
La respuesta en magnitud se obtiene de la siguiente forma:
//Respuesta de magnitud
getf('SCI/modules/DSP/freqz/freqz.sci')
[h1,w] = freqz(numi,deni,512);
plot(w/%pi,20*log10(abs(h1)));grid;
146
xlabel('Frecuencia normalizada');
ylabel('Magnitud');
title(['Respuesta de magnitud']);
Reverberador de sonido ambiente (reverberador de Schroeder)
Para este caso se tiene una combinación de 4 filtros IIR y dos filtros pasatodo como
se indica en el siguiente diagrama.
147
El efecto obtenido es similar al lo que ocurre en un recinto cerrado como es una sala
de conciertos.
Genere el siguiente código de SCILAB para obtener este efecto.
//Reverberador de sonido natural
stacksize('max');
a1=0.6; a2=0.4; a3=0.2; a4=0.1; a5=0.7; a6=0.6; a7=0.8;
R1=700; R2=900; R3=600; R4=400; R5=450; R6=390;
[d]=loadwave('SCI/modules/DSP/wavfile/DSP.wav');
a=length(d)/2;
for i=1:a-1
b=d(1,i);
y(i)=b;
end
f=length(y)/2;
f=round(f)
y1=y(1:f); y2=y(f+1:length(y));
num1=[0,zeros(1,R1-1),1];
den1=[1,zeros(1,R1-1),-a1];
d1=filter(num1,den1,y1); d11=filter(num1,den1,y2);
r=length(d1);
D1=d1;
for i=r+1:r*2-1
148
D1(i)=d11(i-r);
end
num2=[0,zeros(1,R2-1),1];
den2=[1,zeros(1,R2-1),-a2];
d2=filter(num2,den2,y1); d22=filter(num2,den2,y2);
r=length(d2);
D2=d2;
for i=r+1:r*2-1
D2(i)=d22(i-r);
end
num3=[0,zeros(1,R3-1),1];
den3=[1,zeros(1,R3-1),-a3];
d3=filter(num3,den3,y1);d33=filter(num3,den3,y2);
r=length(d3);
D3=d3;
for i=r+1:r*2-1
D3(i)=d33(i-r);
end
num4=[0,zeros(1,R4-1),1];
den4=[1,zeros(1,R4-1),-a4];
d4=filter(num4,den4,y1); d44=filter(num4,den4,y2);
r=length(d4);
149
D4=d4;
for i=r+1:r*2-1
D4(i)=d44(i-r);
end
dIIR=D1+D2+D3+D4;
num5=[a5,zeros(1,R5-1),1];
den5=[1,zeros(1,R5-1),a5];
K=length(dIIR)/2;
H=round(K)-1;
dIIR1= dIIR(1:H); dIIR2=dIIR(H+1:length(dIIR));
dALL1=filter(num5,den5,dIIR1); dALL11=filter(num5,den5,dIIR2);
num5=[a6,zeros(1,R6-1),1];
den5=[1,zeros(1,R6-1),a6];
dALL2=filter(num5,den5,dALL1); dALL22=filter(num5,den5,dALL11);
r=length(dALL2);
DALL2=dALL2;
for i=r+1:r*2-1
DALL2(i)=dALL22(i-r);
end
y=y(1:length(DALL2));
dTOTAL=y+a7*DALL2;
savewave('SCI/modules/DSP/wavfile/Sonido_ambiente',dTOTAL);
150
Reverberador pasatodo.
Para desarrollar un filtro más realista tenemos el reverberador con una estructura de
filtro pasad todo.
Figura 3.65 Reverberador pasatodo
Su función de transferencia está dada por:
H z =
z −R
−R
1×Z
Para poder generar este efecto realice los siguientes pasos:
d=loadwave('SCI/modules/DSP/wavfile/DSP.wav');
stacksize('max');
a=length(d)/2;
for i=1:a-1
b=d(1,i);
y(i)=b;
end
f=length(y)/2;
f=round(f);
151
y1=y(1:f); y2=y(f+1:length(y));
num=[0.8,zeros(1,2900),1];
den=[1,zeros(1,2900),0.8];
d1=filter(num,den,y1); d2=filter(num,den,y2);
r=length(d1);
Salida=d1;
for i=r+1:r*2-1
Salida(i)=d2(i-r);
end
savewave('SCI/modules/DSP/wavfile/ALL_PASS.wav',Salida)
Efecto de retraso
Este es un efecto simple que podemos implementar de la siguiente forma:
Figura 3.66 Filtro de Retardo Referencia (8)
Para ejecutar este efecto digite:
x=loadwave('SCI/modules/DSP/wavfile/DSP.wav');
stacksize('max');
152
xlen=length(x)/2; //calculando el número de muestras del archivo
len=round(xlen-1)
for i=1:len-1
b=x(1,i);
yy(i)=b;
end
a=0.5;
R=5000; //Calculando número de muestras en el retardo
y=zeros(size(yy));
// filtrando la señal
for i=1:1:R+1
y(i) = yy(i);
end
for i=R+1:1:xlen-2
y(i)= yy(i)+ a*yy(i-R);
end;
savewave('SCI/modules/DSP/wavfile/Delay.wav',y);
analyze(y);
Ecualizador.
Finalmente vamos a generar varios efectos tipo ecualizador, utilizando filtros paso
bajo, paso alto y pasa banda.
153
Figura 3.67 Salidas del ecualizador. Referencia (8)
//Ecualizando
stacksize('max');
[x]=loadwave('SCI/modules/DSP/wavfile/DSP.wav');
a=length(x)/2;
for i=1:a-1
b=x(1,i);
y(i)=b;
end
Fn = .031;
N = 62;
//Esta son las ganancias en las tres bandas.
gLP = 0.4; gBP = 1.5; gHP = 1.5;
LP=wfir('lp',N,[Fn 0],'re',-1);
//type='lp','hp','bp','sb' forder=orden del filtro N
//cfreq frecuencias de corte 0<cfreq(1),cfreq(2)<0.5 para paso alto o bajo solo se usa
cfreq(1)
//fpar ventana kaiser (fpar(1)>0 fpar(2)=0)
154
//wtype tipo de ventana ('re','tr','hm','hn','kr','ch')
Fn1 = [.032 .079];
BP = wfir('bp',N,Fn1,'re',-1);
Fn2 = .079;
HP = wfir('hp',N,[Fn2 0],'re',-1);
y1 = convol(LP,y);
y2 = convol(BP,y);
y3 = convol(HP,y);
yA= gHP * y3;
savewave('SCI/modules/DSP/wavfile/Equalizer3.wav',yA);
yB= gLP * y1;
savewave('SCI/modules/DSP/wavfile/Equalizer1.wav',yB);
yC= gBP * y2;
savewave('SCI/modules/DSP/wavfile/Equalizer2.wav',yC);
yD = yA + yB + yC;
savewave('SCI/modules/DSP/wavfile/Equalizer4.wav',yD);
3.7.1
Código MATLAB de la práctica 7.
Procesamiento Digital de Señales IE-0102
Práctica #7 con MATLAB.
Procesamiento de señales de audio.
155
Entre las funciones de MATLAB están las funciones “loadwave” y “wavread” que
permiten cargar un archivo de audio “.wav”.
Primero copie un archivo wav en la carpeta “work” de MATLAB (en nuestro caso el
archivo DSP.wav). Luego teclee el siguiente comando.
[x,fs]=wavread('DSP.wav');
Con
esto
se
abre
el
archivo
DSP.wav
en
el
directorio
C:\MATLAB701\work\DSP.wav
Ahora podemos escuchar el archivo cargado tecleando.
wavplay(x,fs) ;
Eco y reverberación
Frecuentemente se utilizan filtros digitales para el procesamiento de señales de audio,
esto con el objetivo de crear efectos especiales. Dos de estos efectos son el eco y la
reverberación.
Para generar un efecto de eco en nuestra señal de audio teclee lo siguiente:
[d,r,nbits]=wavread('DSP.wav');
num=[0,zeros(1,2900),1];
den=[1,zeros(1,2900),-0.8];
d1=filter(num,den,d);
wavwrite(d1,r,nbits,'Multieco_MATLAB.wav');
wavwrite(d,r,nbits,'Original_MATLAB.wav');
Ahora podemos escuchar nuestro efecto de audio que fue generado y guardado en la
carpeta “work”.
156
Podemos ver la respuesta impulsional típica de este filtro si tecleamos:
%Respuesta impulsional típica.
I =[1,zeros(1,60)];
numi=[0,zeros(1,10),1];
deni=[1,zeros(1,10),-0.8];
d2= filter(numi,deni,I);
figure(1);
stem(d2);grid;
xlabel('Índice de muestreo');
ylabel('Amplitud');
title(['Respuesta impulsional típica']);
La respuesta en magnitud se obtiene de la siguiente forma:
%Respuesta de magnitud
figure(2);
[h1,w] = freqz(numi,deni,512);
plot(w/pi,20*log10(abs(h1)));grid;
xlabel('Frecuencia normalizada');
ylabel('Magnitud');
title(['Respuesta de magnitud']);
Reverberador de sonido ambiente (reverberador de Schroeder)
157
El efecto obtenido es similar al lo que ocurre en un recinto cerrado como es una sala
de conciertos.
Genere el siguiente código de MATLAB para obtener este efecto.
a1=0.6;a2=0.4;a3=0.2;a4=0.1;a5=0.7;a6=0.6; a7=0.8;R1=700;
R2=900;R3=600;R4=400;R5=450;R6=390;
[d,r]=wavread('DSP.wav');
num1=[0,zeros(1,R1-1),1];
den1=[1,zeros(1,R1-1),-a1];
d1=filter(num1,den1,d);
num2=[0,zeros(1,R2-1),1];
den2=[1,zeros(1,R2-1),-a2];
d2=filter(num2,den2,d);
num3=[0,zeros(1,R3-1),1];
den3=[1,zeros(1,R3-1),-a3];
d3=filter(num3,den3,d);
num4=[0,zeros(1,R4-1),1];
den4=[1,zeros(1,R4-1),-a4];
d4=filter(num4,den4,d);
dIIR=d1+d2+d3+d4;
num5=[a5,zeros(1,R5-1),1];
den5=[1,zeros(1,R5-1),a5];
dALL1=filter(num5,den5,dIIR);
158
num5=[a6,zeros(1,R6-1),1];
den5=[1,zeros(1,R6-1),a6];
dALL2=filter(num5,den5,dALL1);
dTOTAL=d+a7*dALL2;
soundsc(dTOTAL,r);
wavwrite(dTOTAL,'Sonido_ambiente_MATLAB.wav');
Reverberador pasa todo.
Para desarrollar un filtro más realista tenemos el reverberador con una estructura de
filtro pasad todo.
Su función de transferencia esta dada por:
H z =
z −R
−R
1×Z
Para poder generar este efecto realice los siguientes pasos:
%Reverberador paso todo
[d,r]=wavread('DSP.wav');
num=[0.8,zeros(1,2900),1];
den=[1,zeros(1,2900),0.8];
d1=filter(num,den,d);
wavwrite(d1,r,'All_pass_MATLAB.wav');
159
Efecto de retraso
Para ejecutar este efecto teclee:
[x,fs,nbits]=wavread('DSP.wav');
xlen=length(x); %Calculando el numero de muestras
a=0.5;
R=5000; %Calculando el número de muestras en el retardo.
y=zeros(size(x));
%Filtrando la señal
for i=1:1:R+1
y(i) = x(i);
end
for i=R+1:1:xlen
y(i)= x(i)+ a*x(i-R);
end;
wavwrite(y,fs,nbits,'Delay.wav')
Podemos ver una gráfica de frecuencia de la señal si aplicamos:
Ecualizador.
Finalmente vamos a generar varios efectos tipo ecualizador, utilizando filtros paso
bajo, paso alto y pasa banda.
%Ecualizando
[x,fs]=wavread('DSP.wav');
160
Wn = .20;
N = 62;
%Estas son las ganancias de las tres bandas
gLP = 0.4; gBP = 1.5; gHP = 1.5; LP = fir1(N,Wn);
Wn1 = [.20, .50];
BP = fir1(N,Wn1);
Wn2 = .50;
HP = fir1(N,Wn2,'high');
y1 = conv(LP,x);
y2 = conv(BP,x);
y3 = conv(HP,x);
yA= gHP * y3;
wavwrite(yA,fs,'Ecualizador3_MATLAB');
yB= gLP * y1;
wavwrite(yB,fs,'Ecualizador1_MATLAB');
yC= gBP * y2;
wavwrite(yC,fs,'Ecualizador2_MATLAB');
yD = yA + yB + yC;
wavwrite(yD,fs,'Ecualizador4_MATLAB');
3.7.2
Resultados de la séptima práctica
161
Figura 3.68 Respuesta impulsional para un reverberador multieco SCILAB y MATLAB.
Figura 3.69 Respuesta de magnitud de un reverberador multieco en SCILAB y MATLAB.
162
Figura 3.70 Gráfica de un filtro de retardo frecuencia obtenida con matlab
CAPÍTULO 4: Elaboración de prácticas de procesamiento
digital de señales en SCICOS.
Las siguientes prácticas fueron realizadas en la versión 4.2 de SCICOS. Entre estas
se encuentran una práctica sobre bancos de filtros digitales, una segunda práctica que trata
sobre filtros digitales paso banda, paso bajo y tipo Notch y la última práctica lleva a cabo
una comparación entre los filtros digitales IIR y FIR.
4.1
Primera práctica.
Procesamiento Digital de Señales IE-0102
Práctica #1 con SCICOS
Filtros digitales.
163
Un filtro digital requiere un procesador digital para realizar cálculos numéricos en los
valores muestreados de la señal. El procesador puede ser un ordenador corriente, como un
PC, o un chip DSP (Digital Signal Processor) especializado.
La parte analógica de la señal debe ser previamente muestreada y digitalizada por un
convertidor AD (analógico-digital). Los números binarios resultantes de la conversión
anterior, que representan valores sucesivos muestreados de la señal de entrada, son
transferidos al procesador, que realiza unos cálculos numéricos sobre ellos. Estos cálculos
suelen ser multiplicaciones de los valores de entrada por unas constantes y suma de las
anteriores multiplicaciones. Si es necesario, los resultados de los cálculos, que representan
los valores de una señal filtrada, son sacados a través de un convertidor DA (digitalanalógico) para convertir la señal a su forma analógica.
La señal de salida es la convolución de la señal de entrada con el filtro.
En la frecuencia el producto de los espectros de entrada y el filtro nos da el espectro
de salida.
Parte a: Resonador digital
Es un filtro pasa banda especial, con un par de polos complejos conjugados ubicados
en la vecindad del círculo unitario, como se muestra en la figura:
164
Figura 4.1 a) Diagrama de polos y ceros y b) respuesta en frecuencia de un resonador. Referencia (9).
La posición angular de los polos determina la frecuencia de resonancia del filtro. El
nombre resonador se debe a que el filtro posee una gran ganancia para señales senoidales
de frecuencia cercanas a la de los polos. Poseen aplicaciones de síntesis de voz y filtrado
pasabanda sencillo.
Los polos complejos conjugados pueden ser ubicados en:
± j o
p 1,2=r e
,0r 1
Se pueden colocar dos ceros, los ceros pueden ser ubicados en z = 1 y z = -1, esto
eliminaría completamente la respuesta del filtro a las frecuencias ω = 0 y ω = π. Si se
eligen colocar los ceros en el origen tendríamos:
H z =
bo
1−r e
j o
−1
z 1−r e
− j o −1
z
=
bo
1− 2rcos o z −1r 2 z−2
La respuesta en frecuencia alcanza su máximo en:
r=cos−1
1r 2
cos wo
2r
Si r es aproximado a 1 r=o y como
o
∣H e j ∣ alcanza su máximo cerca de ω
se elige el factor de ganancia bo de forma que ∣H e j ∣=1 para este caso:
o
b o=1−r 1−2rcos2 or 2
Ejemplo: Tomamos una frecuencia de ωo = π/4 rad.
Para esto tenemos:
165
H z =
b o 1−z −2
−1
2
1−2rcos o z r z
−2
Podemos utilizar:
b o=
1−r
× 1−2rcos2 or 2
2sen o
Con r=0.98, tenemos bo =0.0198, por lo tanto:
H z =
0.1981−z −2
0.198−0.198z −2
=
1−1.386z−10.96z−2 1−1.386z−10.96z−2
Ahora vamos a implementar este filtro en SCICOS. Para ello genere el siguiente
diagrama de bloques en SCICOS.
Figura 4. 2 Diagrama de sistema para realizar filtrado con un filtro resonante digital.
166
Para las ondas senoidales llene los bloques con la siguiente tabla:
Generador senosoidal
Magnitud
Fase
1
0.79
10000
2
1
100
3
0.25
600
4
1,5
0.15
5
1
0.785 (frecuencia ωo)
Para los bloques CLK1 y CLK2 el periodo es 1 y el tiempo inicial es 0.1.
Para el bloque de reloj discreto el tiempo de muestreo es 1 y el offset 0.
El bloque de transformada de transferencia discreta se va a implementar como la
función de transferencia del filtro en si. Digite:
Denominador = z.^2-1.386*z+0.96
Numerador = 0.0198-0.0198*z.^2
Esto es equivalente a H(z) del filtro.
Finalmente para el bloque MScope modifique:
167
El vector Ymin = -2 3, el vector Ymax = 2 3, Refrescamiento de periodo = 50 50 y las
señales serán la entrada (suma de señales senoidales) y la salida del filtro (señal de 0.785
rad/s).
Finalmente proceda a simular y a obtener las señales de entrada y salida del sistema
digital.
Observe además las señales de entrada y la señal muestreada y compárelas.
Parte B: El filtro Notch
El comportamiento del filtro Notch ideal se muestra en la siguiente figura:
Figura 4.3 (a) Comportamiento del filtro Notch ideal y (b) comportamiento real del filtro Notch.
Referencia (9).
168
La figura muestra el comportamiento de un filtro Notch con ceros en ωo y ω1 . Son
útiles en aplicaciones donde se deben eliminar frecuencias especificas. Un ejemplo de ello
son los componentes de 50 ciclos (inducción de la frecuencia de línea) que contaminan las
señales de muy baja amplitud.
La función de sistema para el filtro Notch es:
j o −1
− j o
−1
H z =b o 1−e. z 1−e
z
−1
−2
H z =b o 1−2cos o z z
Este filtro Notch tipo FIR tiene el inconveniente de tener un ancho de banda
relativamente grande, por lo que elimina la frecuencia de interés pero atenuá (gravemente)
otras componentes de frecuencias vecinas. Además la ganancia para ω = 0 (z = 1) es
distinta de la ganancia ω = π (z = -1).
∣H e j ∣=0=2bo 1−cos o
j
∣H e ∣==2bo 1cos o
La diferencia entre ambas puede ser muy grande si la frecuencia que se desea eliminar
está cerca de ω = 0 o de ω = π. A pesar de ello el coeficiente bo se calcula para que la
ganancia sea unitaria.
∣H z ∣z=1=∣H e j ∣=0=1
De donde resulta que bo =[2(1-cosωo)]
La función de sistema de un filtro Notch diseñado para cancelar la frecuencia ωo =
π/4, con ganancia unitario en ω = 0 es:
H z =
1
−1
−2
1− 2 z z
2− 2
169
La respuesta de este filtro se puede observar en la siguiente figura:
Figura 4.4 Respuesta en frecuencia del filtro. Referencia (9).
Para ver el comportamiento del filtro genere este filtro en SCICOS para filtrar una señal de
entrada en ωo = π/4.Para ello utilice el siguiente diagrama en SCICOS.
Figura 4.5 Sistema de prueba de filtro Notch.
170
Utilice un generador sinusoidal con magnitud = 1 y frecuencia = 0.785 (esta va a ser
la señal a eliminar). Los relojes CLK1 y CLK2 tendrán periodo = 1 y tiempo inicial 0.1. El
reloj discreto DCLK debe tener un tiempo de muestreo de 1 y un offset de 0.
Como se muestra en la figura el filtro Notch se generó por medio de tres bloques de
retardo y dos ganancias “a” y ”b”, donde:
a=
1
2− 2
b=−2
Si observa el diagrama se agrega nuevamente la implementación del filtro paso banda
anterior, esto es con la intención de notar la reducción de la señal a filtrar.
Para este diagrama obtenga la señal de salida del filtro Notch y la señal de salida del
filtro paso banda (si utilizamos el mismo diseño anterior deberíamos ver la señal a ωo = 4/π
reducida a aproximadamente cero). Obtenga la señal de entrada, compare y comente.
Para obtener la respuesta en frecuencia del filtro dígite en SCILAB.
-->[y1,y2]=frmag([1.707 -2.41 1.707],[1 0 0],256);
-->plot(y2,y1);
Parte C: Filtro paso bajo
El análisis simbólico es una moderna técnica, para poder estudiar el comportamiento
de muchos sistemas y circuitos. Un ejemplo de ello es en el diseño de circuitos digitales. El
siguiente diagrama muestra un filtro digital de orden 3:
171
Figura 4.6 Filtro digital de orden 3.
Para este filtro su función de trasferencia está dada por:
H z =
z 1b az 2z−aza
3
z za
Tomando a = 0.5 y b = 0.25, tenemos:
2
0.1250.25z0.25z 0.125z
H z =
3
z z0.5
3
Si deseamos ver la respuesta en frecuencia del filtro podemos digitar en SCILAB:
--> b = 1/4; a = 1/2;
-->z=poly(0,'z');
-->h=((z+1)*b*(a*z.^2+z-a*z+a))/(z.^3+z*a)
-->[x,f]=frmag(h,256);
-->plot(f,x)
Al generar el gráfico obtenemos:
172
Figura 4.7 Respuesta en frecuencia de un filtro paso bajo.
Ahora vamos a utilizar este filtro para atenuar señales de la siguiente forma:
Figura 4.8 Aplicación para filtro paso bajo.
173
Tenemos para este caso tres generadores sinusoidales con los siguientes valores:
Señal
Frecuencia
Magnitud
1
100
2
2
0.1
1
3
80
1
Los valores de a y b para el filtro son 0.5 y 0.25 respectivamente, además cargue un
bloque de función de transferencia discreta y genere la función del filtro con la finalidad de
compara la señal de salida por ambos métodos. El tiempo de muestreo del reloj discreto es
de 0.1. Obtenga las señales de salida en ambos casos y compárelas.
4.1.1 Solución a la primera práctica en SCICOS.
Figura 4.9 Señal de salida “Gráfico 1” y señal de entrada “Gráfico 2”.
174
Figura 4.10 Señal de entrada “Grafico 1” y señal muestreada “Gráfico 2”. Filtro paso
banda resonante digital.
Figura 4.11 Señal de entrada muestreada y sin muestrear.
175
Figura 4.12 Señal filtrada por ambos filtros (Gráfico 1) y señal filtrada por el filtro Notch (Gráfico 2).
Figura 4.13 Señal de entrada y salida filtro paso bajo en diagrama de bloques.
176
Figura 4.14 Señal de entrada y salida de filtro paso bajo con el bloque de función de
transferencia.
4.2
Segunda práctica.
Procesamiento Digital de Señales IE-0102
Práctica #2 con SCICOS
Bancos de Filtros
Los bancos de filtros poseen varias aplicaciones en distintas áreas tales como
codificación de voz, procesamiento adaptivo de señales, compresión de imágenes,
transmisión de varias señales a través de una señal, etc.
177
El principal uso de los bancos de filtros, es la habilidad de tener un sistema que
separe la señal en consideración en el dominio de la frecuencia, en dos o más señales, o la
de componer dos o más señales diferentes en una sola señal.
Los bancos de filtros se dividen en dos tipos, los bancos de filtros de análisis y los
bancos de filtros de síntesis.
Figura 4.15 Ejemplo de un banco de filtros sencillo. Referencia (10).
La salida de este sistema se muestra como:
Y z = z.−1 X z en otras palabras
y n= x n−1
Parte A: Simulación de un banco de filtros simple
La señal de entrada sera una señal senoidal de amplitud unitaria, de frecuencia 0.675
(rad/s) o 0.107 Hz y un tiempo de muestreo de 0.2 segundos.
Cargue SCICOS.
--> scicos; //o puede abrirlo desde el menu de SCILAB.
Genere el siguiente diagrama en SCICOS.
178
Figura 4.16 Diagrama de un banco de filtro simple.
Para generar señales senoidales use el bloque “Sinusoid generator” que se encuentra
dando clic en el Menu de SCICOS Palette- Source esto abre una pantalla donde se escoge el
bloque y se agrega a la zona del diagrama.
Dando clic derecho del mouse en el bloque y eligiendo “open set” aparece un cuadro
de diálogo donde se pueden variar los parámetros del bloque. Para este caso escogemos:
magnitud =1, frecuencia = 0.675 fase =0.
Los bloques de reloj de activación están en Palette-Source.
179
Siga la siguiente tabla:
Reloj
Periodo
Tiempo inical
1
1
0
2
0.01
0
3
0.1
4
0.1
Para el reloj 3 (Sample time clock) el tiempo de muestreo es 0.2 y el offset es 0.
El bloque de función SCILAB “Scifun” (se usan 2 para la decimación): este permite
cargar una función de SCILAB o una función generada por nosotros. Se encuentra en
Palette-Others. Para este caso se requiere se estudie el bloque dando clic derecho y luego
Help.
Para las entradas teclee:
[1,1;1,1] (genera dos puertos de entrada)
Se da clic en OK y se despliega un nuevo cuadro de diálogo, donde se define la
función que computa la salida.
En el espacio vamos a digitar:
--> if u1 < 2
y1=u2
else
y1=0
end
180
De momento los demás cuadros que aparezcan no van a variar, solo de clic en OK
hasta que ya no aparezcan más cuadros.
Para los contadores estos irán de 1 a 4.
El valor para el bloque de ganancia es 0.5 (El banco de filtros genera una ganancia de
2 que debemos atenuar).
El bloque Sample and hold (S/H):como lo indica su nombre este bloque muestrea y
espera al próximo evento, para volver a muestrear. Este se encuentra en la paleta “Lineal”.
Este bloque no va a variar sus propiedades.
El bloque reatrdo (1/z): Se encuentra en la paleta “Lineal”, es equivalente a la
función:
Y z =
1
z
Finalmente, para poder ver los resultados cargamos el bloque “Mscope” el cual
debemos llenar de la siguiente forma.
Números de puertos de entrada
1 1
Colores o marcas
No se varia
Numeros de ventanas de salida
No varia
Posición de ventana de salida
No varia
Tamaño de ventana de salida
No varia
Vector Ymin
-1 -1
Vector Ymax
1 1
Refrescar periodo
140 140
Accept herited events 0/1
0
Nombre del osciloscopio
Entrada y salida
181
Para simular el ejercicio en el “Menu” de SCICOS en “Simulate” debe darse un clic
en “Run”.
Tome las capturas de las señales y explique lo que sucede.
Parte B: Filtro de análisis-síntesis
Un Banco de filtros de análisis consiste en un conjunto de filtros, acomodados en
paralelo. Las características de la respuesta en frecuencia de estos bancos de filtros es que
divide la señal en sub-bandas.
Por otra parte el banco de filtros de síntesis consiste en un grupo de filtros cuyas
salidas son sumadas para formar la señal sintetizada.
El siguiente es un banco de filtros de análisis-síntesis donde:
H o z =
1z.−1
1−z.−1
y H 1 z =
2
2
Figura 4.17 Banco de filtros análisis-síntesis. Referencia (10)
Si tomamos:
Go z =
1z.−1
1−z.−1
y G 1 z =
2
2
Esto implica que:
Y z = X z z.−1
182
En otras palabras, y n= x n−1 indicando que la figura es un banco de filtros de
reconstrucción perfecta.
Vamos entonces a simular un filtro de reconstrucción perfecta en SCICOS.
Para ello elabore el siguiente diagrama en SCICOS.
Figura 4.18 Aplicación de un filtro de reconstrucción pérfecta.
Para este caso se mantienen los valores anteriores de los bloques Generador senoidal,
Mscope, relojes 1,2 y 3 y de S/H. Se agrega en 4 ocasiones un nuevo bloque que es el
bloque de función de transferencia discreta. Al abrir este se solicita el denominador y el
numerador los cuales se pueden escribir como si fueran los correspondientes polinomios en
Z y con lenguaje SCILAB. Luego de conectar los bloque simúlese y coméntese sus
resultados.
183
Parte C: Simulación de un banco QMF. (Quadrature Mirror Filter).
La señal de entrada primeramente es filtrada a través de dos filtros Ho(z) y H1(z),
siendo estos filtros paso bajos y paso altos. Cada señal en subbanda es limitada en banda
aproximadamente en un ancho total de π. Las zonas en subbandas son decimadas en un
factor de dos para obtener Vk(n). Cada señal decimada es codifica de forma que las
propiedades especiales de la subbanda son explotadas. Las señales producidas
decodificadas para generar Vo(n) y V1(n) se hacen pasar a través de los filtros F0(z) y F1(z)
para producir la señal de salida. Ho(z) y H1(z) son llamados el filtro análisis. F0(z) y F1(z)
conforman el banco de síntesis.
Figura 4.19 Diagrama de banco QMF. Referencia (10)
184
Procedemos a continuación a generar una simulación de un banco QMF en SCICOS.
Figura 4.20 Diagrama en SCICOS de simulación de un banco de filtros QMF.
Para generar el diagrama use:
Reloj
Periodo
1
0.001
2
0.01
3
0.0001
4
0.1
Para el reloj discreto el tiempo de muestreo es 0.001. La señal senoidal debe ser de
magnitud 1 y de frecuencia 0.5, el contador de SCI1 cuenta de 0.001 hasta 6 e igual para el
contador de SCI2.
En este caso para los bloques SCI (ambos), dé clic derecho y digite:
185
En los puertos de entrada [1,1;1,1] (genera dos puertos de entrada), luego debemos
dar clic en OK , en el siguiente cuadro de texto digitamos:
if u1 < 2
y1=u2
else
y1=0
end
y damos OK hasta salir.
Para los filtros:
H o z =
0.5z0.5
z
H 1 z =
0.5z−0.5
z
F o z =
z1
z
F 1 z =
z −1
z
Para la señal de salida de F1 use un rango en Y de (-0.002, 0.002) para poder observar
la señal. Mida además la señal de salida de los filtros y la salida general. Compare y
comente los resultados.
4.2.1 Resultados de la segunda práctica.
Tras simular el diagrama en SCILAB obtenemos los siguientes gráficos.
186
Figura 4.21 Entrada y salida del diagrama de bloques de un banco de filtros simple.
Figura salida de diagrama 1 primera práctica con SCICOS.
Para Simulink es posible simular el siguiente diagrama.
Figura 4.22 Diagrama en Simulink del primer ejemplo para la práctica 1 de SCICOS.
187
Tras dar los mismos valores y simular el diagrama obtenemos:
Figura 4.23 Resultados de primer diagrama hechos con MATLAB.
Como se muestra la salida es igual a la entrada más un pequeño retraso lo cual es lo
esperado basado en la teoría. Para el caso de SCICOS al no encontrar bloques de upsample
y downsample que posee MATLAB, generamos un algoritmo poco elegante pero que
muestra el comportamiento del sistema.
Para la parte B tenemos los siguientes resultados.
Figura 4.24 Salida y entrada del banco de filtros análisis-síntesis en MATLAB
188
Estas imágenes fueron obtenidas con los mismos valores usados en SCICOS y
utilizando el siguiente diagrama en MATLAB.
Figura 4.25 Diagrama para filtro análisis-síntesis en MATLAB.
Figura 4.26 Entrada y salida de banco de filtro análisis-síntesis en SCILAB.
189
Figura 4.27 El gráfico superior muestra la salida del filtro F0, la figura inferior muestra la salida del
filtro F1.
Figura 4.28 El gráfico superior muestra la salida del sistema, el gráfico inferior es la entrada.
190
Para este caso se observa que aun permanece ruido en la señal, esto debido a que la
aproximación realizada para la decimación no es muy buena, mas permite ver el efecto del
sistema a grandes rasgos.
4.3
Tercera práctica en SCICOS.
Procesamiento Digital de Señales IE-0102
Práctica #3 con SCICOS
Filtros FIR e IIR.
Normalmente un filtro IIR requiere de menos coeficientes que un filtro FIR pero
también requiere las mismas especificaciones. Los filtros IIR se emplean cuando se
requieren transiciones abruptas y alto rendimiento. El precio a pagar es que el filtro IIR se
convierte en inestable o se degradan las características en frecuencia si no se toman algunas
precauciones. Los sistemas IIR no van a presentar una característica de fase exactamente
lineal si queremos que sean causales. La solución más habitual se basa en aproximar el
módulo de la función de transferencia sin preocuparnos de la fase, ya que esta se ajusta en
una etapa posterior de pasa todo.
El siguiente es un ejemplo de un filtro digital IIR que se puede generar en SCILAB.
Este es un filtro elíptico pasobanda de orden 6:
hz=iir(3,'bp','ellip',[.25 .35],[.08 .03]);
[hzm,fr]=frmag(hz,256);
plot2d(fr',hzm')
191
xtitle('Filtro paso banda discreto IIR 0.20<fr<0.40 ',' ',' ');
q=poly(0,'q'); //expresa el resultado en términos de q = z-1
hzd=horner(hz,1/q)
Podemos generar además un filtro pasabanda FIR de la siguiente forma:
hn=eqfir(30,[0 .2;.25 .35;.4 .5],[0 1 0],[1 1 1]);
[hm,fr]=frmag(hn,256);
plot(fr,hm)
Tenemos la siguiente respuesta en frecuencia obtenida.
Figura 4.29 Respuesta en frecuencia de filtro FIR de orden 30 y de un IIR de orden 6.
Ahora tómese tres señales en SCICOS; una a f1 = 500, otra a f2=2500 y una última a
f3 = 5000 y aplique ambos filtros de la siguiente forma.
192
Figura 4.30 Implementación de un filtro IIR paso banda.
Los coeficientes del numerador son: -0.1324, -0.0627, 0.213, 8.82x10-17, -0.213,
0.06127 y 0.1324.
Los coeficientes del denominador son: 0.2432, 0.59, 1.28, 1.42, 1.63, 1.46 y 1.
Para el caso del filtro FIR tenemos el siguiente diagrama:
193
Figura 4.31 Filtro FIR.
Para este caso se tienen los siguientes coeficientes
- 0.0581614,
0.2157638,
0.0180146, - 0.2606135,
- 0.2606135,
0.0180146 , 0.2157638 , - 0.0581614.
0.1769141,
0.1769141,
La transformación bilineal:
Es un mapeo matemático de variables, en filtrado digital esto es un mapeo estándar de
s o del plano análogo dentro de z o el plano digital. Esta transforma filtros analógicos y los
diseña usando técnicas clásicas de filtrado en sus equivalentes discretos.
194
SCILAB utiliza la función “bilin” para llevar a cabo la transformación bilineal. Su
sintaxis es:
[sl1]=bilin(sl,v); //donde sl1 y sl son sistemas lineales y v es un vector con 4 entradas
(v=[a,b,c,d])
El siguiente ejemplo genera la transformación bilineal de un espacio lineal.
s=poly(0,'s');z=poly(0,'z');
w=ssrand(1,1,3);
wtf=ss2tf(w);v=[2,3,-1,4];a=v(1);b=v(2);c=v(3);d=v(4);
[horner(wtf,(a*z+b)/(c*z+d)),ss2tf(bilin(w,[a,b,c,d]))]
clean(ss2tf(bilin(bilin(w,[a,b,c,d]),[d,-b,-c,a]))-wtf)
También se utiliza la función cls2dls con la siguiente sintaxis.
[sl1]=cls2dls(sl,T[,fp]) // T es el periodo de muestreo. Un ejemplo de este comando
es:
s=poly(0,'s');z=poly(0,'z');
sl=syslin('c',(s+1)/(s^2-5*s+2));
//Sistema de tiempo continuo como función de
//transferencia
slss=tf2ss(sl); //Ahora en forma de espacio de estados
sl1=cls2dls(slss,0.2); //sl1= salida de cls2dls
sl1t=ss2tf(sl1) // Convierte en función de transferencia
sl2=horner(sl,(2/0.2)*(z-1)/(z+1)) //Compare sl1 y sl2
[x,f]=frmag(sl1t,256);
plot(f,x)
195
La transformación bilineal evita inconvenientes como el solapamiento que ocurre a
veces en otros métodos como el de transformación invariante al impulso. Además esta
permite mantener la estabilidad del sistema
Vamos a comparar un filtro digital con uno analógico.
Desarrolle el siguiente diagrama en SCICOS.
Para el filtro discreto num [-0.0811, 0.01869, 0.1028], den [0.906, -1.8317, 1]
Para el sistema continuo H=(s+1)/(s^2+0.5*s+2)
Figura 4 .32 Sistema de filtrado analógico y digital.
El reloj discreto tiene un tiempo de muestreo de 0.0015, las señales son de
magnitudes 3, 1, 1 y frecuencias respectivas de 1000, 500 y 0.4.
Para el diagrama simule el sistema y compare el filtro digital con el analógico.
Ahora vamos a generar filtros FIR e IIR usando SCILAB.
//Filtro rechaza banda FIR
196
hn=eqfir(5,[0 .2;.25 .35;.4 .5],[0 1 0],[1 1 1]);
//Filtro paso alto FIR
hn=eqfir(5,[0 .2;.10 .12;.4 .5],[0 0 1],[1 1 1]);
//Filtro paso alto IIR
hz=iir(3,'hp','butt',[.15 .25],[.08 .03]);
Obtenga las respuestas de frecuencia de estos filtros, comente las diferencias entre
estos. Y establezca diferencias entre los filtros FIR e IIR.
4.3.1 Resultados de la tercera práctica en SCICOS.
Figura 4.33 Salida de señal filtrada con filtro IIR.
197
Figura 4 .34 Señal de entrada y de salida para filtro FIR
Figura 4.35 Filtro analógico y filtro digital IIR.
198
CAPÍTULO 5: Conclusiones y recomendaciones.
SCILAB es una herramienta muy útil en el aprendizaje, ya que permite interactuar con
un número considerable de funciones matemáticas y lógicas, que permiten generar
aplicaciones y así fomentar nuestra inventiva. De igual forma SCICOS como herramienta
de SCILAB es capaz de interactuar con este directamente y así generar un entorno gráfico
amigable con el usuario.
A pesar de ser un software muy útil tanto SCILAB como SCICOS aún son muy
simples si los comparamos con MATLAB y SIMULINK. Por ejemplo, al acceder al
número de bloques de SIMULINk podemos ver que este es considerablemente mayor al de
SCICOS. Es debido a esto que muchas aplicaciones de SIMULINK aun están disponibles
en SCICOS. De igual forma sucede entre MATLAB y SCILAB. Otro aspecto en donde
esto se muestra es en el espacio de memoria asignado a las variables. Mientras MATLAB
puede procesar un archivo de audio pequeño en 5 segundos, SCILAB en ocasiones tardaba
hasta 1 hora y el archivo no podía sobrepasar dicho límite de memoria.
Pese a lo anterior SCILAB te permite generar tu propia biblioteca de funciones, claro
esta, debes saber lo básico sobre programación y tener a mano el manual de ayuda de
SCILAB y SCICOS.
Las funciones de MATLAB en si difieren bastante a las de SCILAB, en algunas
ocasiones, estas cumplen una labor similar y hasta tienen el mismo nombre en ambos
softwares, más la mayoría de las funciones difieren en uso y aplicación. Un ejemplo de ello
es la función “freqz” de MATLAB, ya que esta función puede hacer o tomar distintas
199
decisiones dependiendo de sus entradas asignadas. En otras palabras una función de
MATLAB puede hacer la misma función que dos o más funciones de SCILAB.
Se recomienda a aquellas personas que desean explorar las funcionalidades de
SCILAB y SCICOS el uso de las herramientas informáticas que se encuentran en la página
oficial de SCILAB, en especial recomiendo para los amantes de las telecomunicaciones el
de librerías de telecomunicaciones y bloques para SCICOS.
200
BIBLIOGRAFÍA
Páginas web:
1.
SCILAB
GROUP.
“Signal
Processigng
With
SCILAB”,
http://pauillac.inria.fr/cdrom/ftp/scilab/documentation/pdf/signal.pdf.
2.
Delicado B. “Introducción al modelado y simulación de sistemas con la Toolbox
SCICOS de SCILAB”, http://pauillac.inria.fr/cdrom/ftp/scilab/contrib/delicado/
3.
Delicado B. “Manual de introducción al tratamiento de señales con SCILAB
para
usuarios
de
MATLAB”.
http://pauillac.inria.fr/cdrom/ftp/scilab/contrib/delicado/scilab.pdf
4.
SCILAB
GROUP.
“Introduction
to
SCILAB”.
a
SCILAB”.
http://pauillac.inria.fr/cdrom/ftp/scilab/documentation/pdf/intro.pdf-0
5.
Mora
Hector.
“Introducción
http://www.scilab.org/publications/SCISPANISH/Intro_Spanish.pdf
6.
Also
Ch.
“Comparing
SCILAN
and
MATLAB”.
http://www.num.uni-
sb.de/iam/studium/vorlesungen/ss2007/prama/praktische_aufgaben/matlab/Comparing
%20MATLAB%20and%20SCILAB.pdf
7.
Gilberto
E.
“Programming
with
SCILAB”
http://www.infoclearinghouse.com/files/scilab/scilab02.pdf
8.
“Demostraciones
con
MATLAB.”
http://www.lpi.tel.uva.es/~nacho/docencia/ing_ond_1/trabajos_02_03/Acustica_arq
uitectonica/practica/MATLAB.HTML
201
9.
“Diseño
de
filtros
sencillos”.
http://www.ingelec.uns.edu.ar/pds2803/Materiales/Cap10/10-Cap10.pdf
10.
“Bancos
de
filtros
digitales”.
http://catarina.udlap.mx/u_dl_a/tales/documentos/lem/madrid_q_a/capitulo_5.html#
