Mudanças entre as edições de "PSD29007-Engtelecom(2020-1) - Prof. Marcos Moecke"
(→ATUAL) |
|||
(35 revisões intermediárias pelo mesmo usuário não estão sendo mostradas) | |||
Linha 1 020: | Linha 1 020: | ||
===Unidade 3=== | ===Unidade 3=== | ||
− | {{collapse_top | + | {{collapse_top | Unidade 3 - Filtros FIR}} |
;Aula 20 (21 mai): Filtros digitais: Filtros FIR | ;Aula 20 (21 mai): Filtros digitais: Filtros FIR | ||
Linha 1 950: | Linha 1 950: | ||
::*Os filtros IIR de ordem superior a 2 podem ser implementados nas FD I ou II e na FT I ou II. No entanto nessa configuração tendem a ficar instáveis ao terem os coeficientes quantizados, e também terem uma significativa alteração da resposta em frequência. Para reduzir esses problemas uma possível solução é a decomposição em filtros de 2ª ordem para serem associados na forma em Cascata ou Paralela. | ::*Os filtros IIR de ordem superior a 2 podem ser implementados nas FD I ou II e na FT I ou II. No entanto nessa configuração tendem a ficar instáveis ao terem os coeficientes quantizados, e também terem uma significativa alteração da resposta em frequência. Para reduzir esses problemas uma possível solução é a decomposição em filtros de 2ª ordem para serem associados na forma em Cascata ou Paralela. | ||
− | |||
− | |||
===Uso do Simulink para processamento de sinais=== | ===Uso do Simulink para processamento de sinais=== | ||
;Aula 32 (9 jul) | ;Aula 32 (9 jul) | ||
Linha 1 962: | Linha 1 960: | ||
*O Simulink possui muitos blocos que permitem a implementação d filtros. Para os filtros IIR e FIR recomendo o uso dos blocos [https://www.mathworks.com/help/dsp/ref/digitalfilterdesign.html Digital Filter Design], [https://www.mathworks.com/help/dsp/ref/filterrealizationwizard.html Filter Realization Wizard]. | *O Simulink possui muitos blocos que permitem a implementação d filtros. Para os filtros IIR e FIR recomendo o uso dos blocos [https://www.mathworks.com/help/dsp/ref/digitalfilterdesign.html Digital Filter Design], [https://www.mathworks.com/help/dsp/ref/filterrealizationwizard.html Filter Realization Wizard]. | ||
− | |||
;Aula 34 (6 ago) | ;Aula 34 (6 ago) | ||
Para aprender o básico do Simulink recomendo assistir a estes vídeos da Mathworks | Para aprender o básico do Simulink recomendo assistir a estes vídeos da Mathworks | ||
Linha 1 968: | Linha 1 965: | ||
*[https://www.mathworks.com/videos/introduction-to-simulink-81623.html?form_seq=conf840&elqsid=1430251491350&potential_use=Education&country_code=BR Simulink for New Users -(duração 54m07s)], esse vídeo ensina a usar o ambiente de simulação de forma mais efetiva, indo desde a criação de um modelo até o compartilhamento do modelo com uma equipe e criação de templates para uso como base de projetos. O uso de dashboard é mostrado de forma resumida. | *[https://www.mathworks.com/videos/introduction-to-simulink-81623.html?form_seq=conf840&elqsid=1430251491350&potential_use=Education&country_code=BR Simulink for New Users -(duração 54m07s)], esse vídeo ensina a usar o ambiente de simulação de forma mais efetiva, indo desde a criação de um modelo até o compartilhamento do modelo com uma equipe e criação de templates para uso como base de projetos. O uso de dashboard é mostrado de forma resumida. | ||
− | + | * Construa o modelo de simulação mostrado na AE4 | |
− | ; | + | |
− | * | + | |
− | * | + | ;Aula XX (13 ago): |
− | + | *Agrupar todas as entradas em um subsistema (input_source) | |
− | * | + | *Agrupar as saídas (medições) em um subsistema (measuarements) |
+ | *Agrupar todos os blocos do sistema desenvolvido sob um subsistema (DUT). | ||
+ | :*ver: [https://www.mathworks.com/help/simulink/ug/creating-subsystems.html Create a Subsystem], [https://www.mathworks.com/help/simulink/ug/creating-subsystems.html#f4-7371 Create Subsystem from Selection], [https://www.mathworks.com/help/simulink/ug/navigate-subsystems-in-the-model-hierarchy.html Navigate Model Hierarchies] | ||
+ | :*pode interessar a vocês também os vídeos: [https://www.youtube.com/watch?v=7IUyTPQpQwc], [https://www.youtube.com/watch?v=3GK7k_PFEls] | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | ; | + | ;Aula XX (17 ago) |
− | * | + | *Passos adicionais para converter de Matlab/Simulink para HDL. |
− | :[ | + | :*Ver [https://www.mathworks.com/help/hdlcoder/ug/guidelines-for-checking-model-compatibility.html Basic Guidelines for Modeling HDL Algorithm in Simulink] |
− | * | + | :*Ver [https://www.mathworks.com/help/hdlcoder/ug/guidelines-for-model-setup-and-checking-model-compatibility.html Guidelines for Model Setup and Checking Model Compatibility] |
− | + | :*Ver [https://www.mathworks.com/help/hdlcoder/ug/basic-guidelines-for-blocks-usage.html Modeling with Simulink, Stateflow, and MATLAB Function Blocks] | |
− | + | :*Executar o hdlsetup('nome_modelo') para configurar o modelo antes da conversão. Se quiser customizar o comando edite o arquivo hdlsetup.m e salve com myhdlsetup.m | |
− | + | edit hdlsetup.m | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | + | *Experimentar com esse circuito contador até M. | |
− | + | :*[https://www.mathworks.com/help/hdlcoder/gs/create-hdl-compatible-simulink-model.html Create Simulink Model for HDL Code Generation] | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | {{ | + | {{fig|5.1|Divisão HDL_DUT e testbench|ContadorHDLCoder.png|800 px|}} |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | + | {{fig|5.2|Subsistema HDL_DUT|DUT_ContadorHDLCoder.png|800 px|}} | |
− | * | + | *'''NOTA''': Para funcionar a simulação é importante que o solver esteja setado para discreto, pois o contador é um sistema discreto pois utiliza os blocos '''Delay'''. Antes de simular aplique o hdlsetup ao modelo. |
− | + | hdlsetup('nome_modelo') | |
− | * | + | *A invés de fixar o [Output data type] dos blocos [Constant] em uint32 conforme mostrado na página da mathworks, escolha um tipo de dado da entrada count_threshold, e deixe os blocos internos como [Inherit: Inherit via back propagation], para que eles se ajustem conforme a necessidade. |
− | + | :*Verifique os códigos VHDL gerados quando é utilizado double, int8 e uint32. | |
− | + | *Para gerar o '''código VHDL''' pode se digitado '''makehdl('HDL_DUT')''', ou também usar a interface gráfica, com clique-direito sobre o bloco HDL_DUT e selecionando '''[HDL Code > Generate HDL for Subsystem]''', ou ainda pelo menu '''[Code > HDL Code > Generate HDL]'''. | |
+ | *Para que o testbench seja separado em arquivos do tipo .dat, em menu '''[Code > HDL Workflow Advisor]''', no item '''3.1.3 Set Testbench Option''', marque '''[x] Multi-file test bench''' e '''[x] Use file I/O for read/write bench data'''. | ||
+ | *Para gerar o código VHDL para o '''testbench''' usar a interface gráfica pelo menu '''Code > HDL Code > Generate testbench]'''. | ||
+ | *Para fazer a simulação do sistema em VHDL, abra o Modelsim e vá para a pasta do projeto. | ||
+ | cd hdl_prj/hdlsrc/hdlcoder_simple_up_counter/ | ||
+ | *Compile os arquivos do projeto | ||
+ | do HDL_DUT_compile.do | ||
+ | *Compile os arquivos do testbench | ||
+ | do HDL_DUT_tb_compile.do | ||
+ | *Realize a simulação automática do contador. | ||
+ | do HDL_DUT_tb_sim.do | ||
− | + | {{fig|5.3|Subsistema HDL_DUT simulado no Simulink|DUT_ContadorSimulink.png|800 px|}} | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | + | {{fig|5.4|Subsistema HDL_DUT simulado no Modelsim|DUT_ContadorModelsim.png|800 px|}} | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | * | + | *Observe que o sinal simulado em VHDL é identico ao sinal simulado pelo Simulink, além disso observe que a frase abaixo aparece no console confirmando que o sistema HDL_DUT está correto. O próximo passo seria usar o VDHL para implementar o sistema. |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | * | + | ** Note: **************TEST COMPLETED (PASSED)************** |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | + | ;Aula XX (20 ago) | |
+ | *Filtros Digitais: Quantização | ||
+ | *Como criar dados de ponto fixo no Matlab [https://www.mathworks.com/help/fixedpoint/gs/fixed-point-basics.html Create Fixed-Point Data in MATLAB], [https://www.mathworks.com/help/simulink/ug/fixed-point-numbers.html Fixed-Point Numbers] | ||
− | + | ||
+ | a_sfix = fi(0.1) % 0.1 representado com signed, 16 bits no total com os bits de fração determinados para representar o sinal | ||
+ | b_sfix = fi(-0.1) % 0.1 representado com signed, 16 bits no total com 10 bits de fração | ||
+ | c_sfix = fi(0.1,1,5,4) % 0.1 representado com signed, 5 bits no total com 4 bits de fração | ||
+ | d_sfix = fi(-0.1,1,5,4) % -0.1 representado com signed, 5 bits no total com 4 bits de fração | ||
+ | e_sfix = fi(-0.1,0,5,4) % -0.1 representado com unsigned, 5 bits no total com 4 bits de fração => ERRO | ||
+ | a_float = 0.1 | ||
+ | b_float = -0.1 | ||
+ | fi(0:0.3:10,0,8,0) | ||
+ | Para observar a precisão da representação mude o formato numérico para | ||
+ | format long | ||
+ | format hex | ||
+ | format short % formato default | ||
+ | Experimente com outros números como (10.3 3.25 pi e) | ||
− | + | *Caso o dado tem um outro formato, é possível usar o quantizer-quantize para converter o dado para ponto fixo (ou outro formato) | |
− | + | *Além disso, os números de ponto fixo podem ser representado com sinal (fixed) ou sem sinal (ufixed) | |
− | * | + | <pre> |
− | + | DataMode | |
− | + | Type of arithmetic used in quantization. This property can have the following values: | |
− | |||
− | + | fixed — Signed fixed-point calculations | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | + | float — User-specified floating-point calculations | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | + | double — Double-precision floating-point calculations | |
− | |||
− | |||
− | |||
− | |||
− | + | single — Single-precision floating-point calculations | |
− | |||
− | |||
− | |||
+ | ufixed — Unsigned fixed-point calculations | ||
− | + | The default value of this property is fixed. | |
+ | </pre> | ||
+ | |||
+ | :*Ver [https://www.mathworks.com/help/fixedpoint/ref/quantize_method.html quantize method] e [https://www.mathworks.com/help/fixedpoint/ref/quantizer-object-properties.html quantizer Object Properties] | ||
+ | <pre> | ||
+ | v = -2:0.3:2 | ||
+ | q = quantizer('fixed', [5 4]) | ||
+ | quantize(q,0.1) | ||
+ | quantize(q,pi) | ||
+ | quantize(q,v) | ||
+ | qu = quantizer('ufixed', [16 4]) | ||
+ | quantize(qu,-0.1) | ||
+ | quantize(qu,-pi) | ||
+ | quantize(qu,v) | ||
+ | </pre> | ||
+ | Note neste caso que a quantidade de bits total e número de casas fracionárias limitam a representação dos números. | ||
+ | range(q) | ||
− | |||
− | |||
− | + | Para observar os bits que representam o número pode ser usada a função num2bin e num2hex. Note que o format hex mostra o valor correspondente no padrão IEEE 754 (floating point) | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | + | <pre> | |
− | |||
− | |||
− | |||
− | |||
− | < | ||
− | |||
− | |||
− | |||
− | |||
− | |||
x=-0.2; | x=-0.2; | ||
% Word length = 8, fraction length = 7 | % Word length = 8, fraction length = 7 | ||
− | q=quantizer([8,7]) | + | q=quantizer([8,7]) |
+ | range(q) | ||
xq=quantize(q,x); | xq=quantize(q,x); | ||
− | binxq=num2bin(q,xq) | + | binxq=num2bin(q,xq); |
− | % Word length = 16, fraction length = | + | % Word length = 16, fraction length = 10 |
− | q1=quantizer([ | + | q1=quantizer([160 150]) |
+ | range(q1) | ||
xq1 = quantize(q1,x); | xq1 = quantize(q1,x); | ||
− | binxq1=num2bin(q1,xq1) | + | binxq1=num2bin(q1,xq1); |
− | </ | + | hexxq1=num2hex(q1,xq1); |
+ | x | ||
+ | xq | ||
+ | xq1 | ||
+ | disp(['x=',num2str(x), ',xq=',num2str(xq), ',bin=', binxq, ',xq1=',num2str(xq1),',bin=', binxq1 ]) | ||
+ | format hex | ||
+ | xq1 | ||
+ | hexxq1 | ||
+ | </pre> | ||
+ | A precisão da representação numérica também varia conforme o numero de bits usados para a parte fracionária. Para saber a precisão (valor correspondente ao bit menos significativo) use a função eps(q). | ||
+ | <pre> | ||
+ | q=quantizer('ufixed', [4,1]); | ||
+ | %q=quantizer([4,1],'fixed') | ||
+ | % q=quantizer([4,0],'ufixed') | ||
+ | % q=quantizer([4,0],'fixed') | ||
+ | % q=quantizer([4,-1],'ufixed') | ||
+ | % q=quantizer([4,-1],'fixed') | ||
+ | tostring(q) | ||
+ | range(q) | ||
+ | eps(q) | ||
+ | xq=quantize(q,x); | ||
+ | binxq=num2bin(q,xq); | ||
+ | xq | ||
+ | binxq | ||
+ | </pre> | ||
+ | |||
+ | *Na quantização um efeito que deve ser controlado é o overflow, no qual o valor a ser representado é superior ao possível para a quantidade de bits escolhida. Existe o modo de saturação e o modo de wrap. | ||
+ | <pre> | ||
+ | q=quantizer([3 0],'fixed','round','saturate'); | ||
+ | quantize(q,0:0.5:16) | ||
+ | q=quantizer([3 0],'ufixed','round','saturate'); | ||
+ | quantize(q,0:0.5:16) | ||
+ | q=quantizer([3 0],'fixed','round','wrap'); | ||
+ | quantize(q,0:0.5:16) | ||
+ | q=quantizer([3 0],'ufixed','round','wrap'); | ||
+ | quantize(q,0:0.5:16) | ||
+ | </pre> | ||
+ | Note a diferença entre estes 4 quantizadores acima. | ||
+ | |||
+ | ;Aula XX (24 ago) | ||
+ | *No Simulink os dados podem ser representados pelos seguintes formatos [https://www.mathworks.com/help/simulink/ug/data-types-supported-by-simulink.html Data Types Supported by Simulink]. Mas com a Toolbox fixed-point, os dados podem ser especificados também como ponto fixo, o que possibilita a geração de hardware e software usando a representação em ponto fixo. Veja alguns detalhes em [https://www.mathworks.com/help/simulink/ug/specify-data-types-using-data-type-assistant.html#bsnnyna-1 Specify Data Types Using Data Type Assistant - Specifying a Fixed-Point Data Type]. | ||
+ | |||
+ | *O recomendado é realizar o seguinte fluxo de projeto. [https://www.mathworks.com/help/fixedpoint/conversion-using-simulation-data.html Convert to Fixed Point]. | ||
+ | |||
+ | *O bloco [https://www.mathworks.com/help/simulink/slref/datatypeconversion.html Data Type Conversion] permite converter entre tipos de dados e agiliza o processo [https://www.mathworks.com/help/simulink/slref/convert-data-types-in-simulink-models.html Convert Data Types in Simulink Models]. | ||
+ | |||
+ | *Como a conversão do tipo de dado de ponto flutuante 64 bits (double) para ponto fixo, resulta na quantização dos coeficientes do filtro, é necessário fazer uma nova análise dos filtros projetados para verificar qual é o comportamento dos mesmos com esses coeficientes, pois dependendo da quantização um filtro pode não atender mais a especificação original. No caso dos IIR pode até se tornar instável. | ||
+ | No caso dos filtros FIR, escolha uma quantidade de bits suficiente para manter a resposta de frequência especificada, ou modifique o filtro visando reduzir o número de bits necessários. No caso dos IIR, utiliza uma estrutura de seções de segunda ordem (SOS) para a implementação dos filtros. | ||
+ | *Toda a análise acima pode ser feita diretamente com o FDAtool, e os filtros realizados depois de quantizados podem ser exportados para o Simulink, conforme será visto em aula. | ||
− | :* | + | ;Ver também: |
− | * | + | :*[https://www.mathworks.com/help/simulink/ug/benefits-of-using-fixed-point-hardware.html Benefits of Using Fixed-Point Hardware] |
+ | :*[https://www.mathworks.com/help/fixedpoint/ug/precision-and-range.html#f6481 Precision and Range], [https://www.mathworks.com/help/simulink/ug/scaling-precision-range-quantization.html Scaling, Precision, and Range] | ||
+ | :*[https://www.mathworks.com/help/dsp/ref/fixed-point-filter-properties.html Fixed-Point Filter Properties] | ||
+ | :*[https://www.mathworks.com/help/dsp/ug/use-fdatool-with-dsp-system-toolbox-software.html?searchHighlight=fdatool&s_tid=doc_srchtitle Use Filter Designer with DSP System Toolbox Software] | ||
+ | :*[https://www.mathworks.com/help/fixedpoint/ug/tutorial-steps.html Convert Floating-Point Model to Fixed Point] | ||
+ | :*[http://www.clivemaxfield.com/diycalculator/sp-round.shtml Tipos de arredondamento], [https://www.eetimes.com/document.asp?doc_id=1274485 An introduction to different rounding algorithms] | ||
+ | *Para interpretar o valor numérico de dados em ponto flutuante use esse [https://baseconvert.com/ieee-754-floating-point conversor IEEE 754]. | ||
− | + | ====ATUAL==== | |
− | ;Aula | + | ;Aula XX (27 ago) |
− | * | + | *Neste dia foi usado um vídeo gravado mostrando como é feito o passo a passo de um projeto de filtro cujos coeficientes já foram determinados, até a descrição do hardware em HDL. |
− | |||
− | + | ====NEXT==== | |
− | + | ;Aula PF (31 ago) | |
− | + | *Definição dos requisitos e prazos do projeto final a ser realizado em equipes (ou individual). | |
− | + | * Neste dia todos alunos deverão estar on line com o vídeo ligado (pode ser a partir do celular). | |
− | + | * Vocês poderão tirar suas dúvidas sobre o projeto neste dia. | |
− | * | + | * Depois desse encontro não teremos mais encontros síncronos, apenas o atendimento, que será com hora marcada pelo grupo do SLACK nos dias de atendimento paralelo ou no horário das aulas. |
− | |||
{{collapse bottom}} | {{collapse bottom}} | ||
Linha 2 245: | Linha 2 229: | ||
{{collapse bottom}} | {{collapse bottom}} | ||
− | + | {{collapse top | AE3 - Projeto de Filtro Digital FIR (Entrega e prazos ver Moodle)}} | |
− | {{collapse top | | ||
Essa avaliação visa verificar se você conhece a metodologia de projeto de filtros digital FIR com janelas fixas, janelas ajustáveis e usando o algoritmo de Park-McCleallan (PM). Nesta avaliação cada equipe deverá realizar o projeto de 2 filtros analógicos usando janela fixa e ajustáveis e todos os 4 filtros usando o PM. Alguns filtros foram modificados em relação a atividade anterior. | Essa avaliação visa verificar se você conhece a metodologia de projeto de filtros digital FIR com janelas fixas, janelas ajustáveis e usando o algoritmo de Park-McCleallan (PM). Nesta avaliação cada equipe deverá realizar o projeto de 2 filtros analógicos usando janela fixa e ajustáveis e todos os 4 filtros usando o PM. Alguns filtros foram modificados em relação a atividade anterior. | ||
Linha 2 309: | Linha 2 292: | ||
;Exemplos de formatação de figuras: | ;Exemplos de formatação de figuras: | ||
− | + | {{fig|AE3.1| Resposta ao impulso de um filtro digital FIR |Ex_impulseFIR.png|1000 px|}} | |
− | + | {{fig|AE3.2| Resposta em frequência de 3 filtros passa altas do tipo FIR |Ex_FiltroFIRHP.png|1000 px|}} | |
− | [[ | + | {{fig|AE3.3| Diagrama de polos e zeros de um filtro digital FIR |Ex_zplaneFIR.png|600 px|}} |
− | + | ||
− | </ | + | {{collapse bottom}} |
+ | |||
+ | {{collapse top | AE4 - Simulação de sistemas DSP com Simulink (Entrega e prazos ver Moodle)}} | ||
+ | |||
+ | Como atividade de estudo realizar a montagem do modelo indicado na figura abaixo e fazer a simulação, usar fa = 8000Hz. | ||
+ | ;PASSO 1 - Entrar no Simulink: | ||
+ | * Abra o Matlab e crie uma pasta PSD29007 | ||
+ | * Entre no Simulink criando um novo modelo digitando | ||
+ | simulink | ||
+ | * Em seguida salve o modelo vazio com o nome '''aula34.slx''' | ||
+ | |||
+ | ;PASSO 2 - Criando o modelo slx: | ||
+ | * crie as variáveis de parâmetro para os blocos do simulink. Digite no matlab: | ||
+ | fa = 8000 % Sampling frequency; | ||
+ | Ta = 1/fa % Sample time; | ||
+ | spf = 1 % Samples per frame; | ||
+ | v1 = 0.2 % Sine amplitude; | ||
+ | f1 = 500 % Sine frequency; | ||
+ | G = 0.05 % Gain; | ||
+ | |||
+ | ;PASSO 3 - Construindo o circuito com as fontes ('''source''') de sinal: | ||
+ | * Insira os blocos que deseja utilizar para construir a seleção da fonte (ver o diagrama de blocos) | ||
+ | |||
+ | {{fig|AE4.1| Modelagem da seleção das fontes de sinal |SelectSourceSimulink.png|400 px|}} | ||
+ | |||
+ | * Configure os parâmetros de cada bloco. | ||
+ | {{collapse top | Configurar o bloco [https://www.mathworks.com/help/dsp/ref/sinewave.html sinewave]}} | ||
+ | ;Amplitude — Amplitude of sine waves: v1 | ||
+ | ;Frequency (Hz) — Frequency of each sine wave: f1 | ||
+ | ;Phase offset (rad) — Phase offset: 0 (default) | ||
+ | ;Sample mode — Continuous or discrete sampling mode: Discrete (default) | ||
+ | ;Output complexity — Real or complex waveform: Real (default) | ||
+ | ;Computation method — Method for computing discrete-time sinusoids: Trigonometric fcn (default) | ||
+ | ;Sample time — Sample period: Ta | ||
+ | ;Samples per frame — Samples per frame: spf | ||
+ | ;Resetting states when re-enabled — State behavior inside enabled subsystems: Restart at time zero (default) | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | {{collapse top | Configurar o bloco [https://www.mathworks.com/help/dsp/ref/chirp.html chirp]}} | ||
+ | ;Frequency sweep — Type of frequency sweep : Linear (default) | ||
+ | ;Sweep mode — Sweep mode: Unidirectional (default) | ||
+ | ;Initial frequency (Hz) — Initial frequency: 1 | ||
+ | ;Target frequency (Hz) — Target frequency: fa/2 | ||
+ | ;Target time (s) — Target time of sweep: 2 | ||
+ | ;Sweep time (s) — Sweep time: 2 | ||
+ | ;Initial phase (rad) — Initial phase of cosine output: 0 (default) | ||
+ | ;Sample time — Output sample period: Ta | ||
+ | ;Samples per frame — Samples per frame: spf | ||
+ | ;Output data type — Output data type: Double (default) | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | {{collapse top | Configurar o bloco [https://www.mathworks.com/help/dsp/ref/randomsource.html random source]}} | ||
+ | ;Source type — Uniform or Gaussian: Uniform (default) | ||
+ | ;Minimum — Minimum value of uniform distribution: -1 | ||
+ | ;Maximum — Maximum value of uniform distribution: 1 (default) | ||
+ | ;Repeatability — Repeatability of block output: Not repeatable | ||
+ | ;Inherit output port attributes — Inherit output port parameters from downstream block: off (default) | ||
+ | ;Sample mode — Discrete or continuous: Discrete (default) | ||
+ | ;Sample time — Output sample period: Ta | ||
+ | ;Samples per frame — Samples per output frame: spf | ||
+ | ;Output data type — Output data type: Double (default) | ||
+ | ;Complexity — Complexity of output: Real (default) | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | ;PASSO 4 - Construindo o circuito com os receptores ('''sink''') de sinal: | ||
+ | * Insira os blocos que deseja utilizar para receptores (ver o diagrama de blocos) | ||
+ | {{fig|AE4.2| Modelagem das medições de sinal |SinkSimulink.png|800 px|}} | ||
+ | |||
+ | * Configure os parâmetros de cada bloco. | ||
+ | {{collapse top | Configurar o bloco [https://www.mathworks.com/help/dsp/ref/timescope.html time scope]}} | ||
+ | Abra a configuração [View > Configuration properties] | ||
+ | |||
+ | *Na aba [Main] | ||
+ | ;Open at simulation start — Specify when scope window opens: on (default for Time Scope) | ||
+ | ;Display the full path — Display block path on scope title bar: off (default) | ||
+ | ;Number of input ports — Number of input ports on scope block: 2 | ||
+ | ;Layout — Number and arrangement of displays: 1 coluna 2 linhas | ||
+ | ;Sample time — Simulation interval between scope updates: -1 (for inherited) (default) | ||
+ | ;Input processing — Channel or element signal processing: Columns as channels (frame based) (default for Time Scope) | ||
+ | ;Maximize axes — Maximize size of plots: Auto (default for Time Scope) | ||
+ | |||
+ | *Na aba [Time] | ||
+ | ;Time span — Length of x-axis to display: 2 | ||
+ | ;Time span overrun action — Display data beyond visible x-axis: Wrap (default) | ||
+ | ;Time units — x-axis units: Metric (default for Time Scope) | ||
+ | ;Time display offset — x-axis offset: 0 (default) | scalar | vector | ||
+ | ;Time-axis labels — Display of x-axis labels: All (default for Time Scope) | ||
+ | ;Show time-axis label — Display or hide x-axis labels: on (default for Time Scope) | ||
+ | |||
+ | *Na aba [Display] | ||
+ | ;Active display — Selected display: 1 (default) | ||
+ | ;Title — Display name: %<SignalLabel> (default) | ||
+ | ;Show legend — Display signal legend: on | ||
+ | ;Show grid — Show internal grid lines: on (default) | ||
+ | ;Plot signals as magnitude and phase — Split display into magnitude and phase plots: off (default) | ||
+ | ;Y-limits (Minimum) — Minimum y-axis value: -10 (default) | ||
+ | ;Y-limits (Maximum) — Maximum y-axis value: 10 (default) | ||
+ | ;Y-label — Y-axis label: Amplitude (default for Time Scope) | ||
+ | |||
+ | *Na aba [Logging] | ||
+ | ;Limit data points to last — Limit buffered data values: off and 5000 (default) | ||
+ | ;Decimation — Reduce amount of scope data to display and save: off, 2 (default) | ||
+ | ;Log data to workspace — Save data to MATLAB workspace: off (default) | ||
+ | ;Variable name — Name of saved data variable: ScopeData (default) | ||
+ | ;Save format — MATLAB variable format: Dataset (default) | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | {{collapse top | Configurar o bloco [https://www.mathworks.com/help/dsp/ref/spectrumanalyzer.html spectrum analyser]}} | ||
+ | Abra a configuração [View > Spectrum Settings] | ||
+ | |||
+ | *Main option | ||
+ | <!--;Input domain — Domain of the input signal: Time (default) | Frequency--> | ||
+ | ;Type — Type of spectrum to display: Power (default) | ||
+ | ;View — Spectrum view: Spectrum (default) | ||
+ | ;Sample rate — Sample rate of the input signal in hertz: Inherited (default) | ||
+ | ;Full frequency span — Use entire Nyquist frequency interval: on (default) | ||
+ | ;RBW (Hz) — Resolution bandwidth: Auto (default) | ||
+ | |||
+ | *Window Options | ||
+ | ;Overlap (%) — Segment overlap percentage: 0 (default) | ||
+ | ;Window — Windowing method: Hann (default) | ||
+ | ;NENBW — Normalized effective noise bandwidth: | ||
+ | |||
+ | *Trace Options | ||
+ | ;Units — Spectrum units: dBm (default) | ||
+ | ;Averages — Number of spectral averages: 1 (default) | ||
+ | ;Reference load — Reference load: 1 (default) | ||
+ | ;Scale — Scale of frequency axis: Linear (default) | ||
+ | ;Offset — Constant frequency offset: 0 (default) | ||
+ | ;Normal trace — Normal trace view: off | ||
+ | ;Max hold trace — Maximum hold trace view: on | ||
+ | ;Min hold trace — Minimum hold trace view: off (default) | ||
+ | ;Two-sided spectrum — Enable two-sided spectrum view: off (default) | ||
+ | *Ver mais em: [https://www.mathworks.com/help/dsp/ug/configure-spectrum-analyzer.html Configure Spectrum Analyzer] | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | |||
+ | {{collapse top | Criar um Filtro usando o [Digital Filter Design]}} | ||
+ | *Use o bloco '''Digital Filter Design''' para projetar e implementar um filtro digital FIR ou IIR. | ||
+ | *De um duplo click sobre o bloco, e escolha as configurações que desejar. | ||
+ | *Após configurar o filtro ou importar os coeficientes projetados no Matlab, clique em [Design Filter]. | ||
+ | *No menu [Edit > Convert Structure], escolha a implementação desejada. | ||
+ | {{collapse bottom}} | ||
+ | |||
+ | *Para melhorar a visualização dos sinais no Simulink, faça os seguintes procedimentos: | ||
+ | :* Ative a visualização das dimensões das portas ['''Display > Signal & Ports > Signal Dimensions'''] ou [ALT]+D+S+D+[ENTER] | ||
+ | :* Ative a visualização do tipo de dados das portas ['''Display > Signal & Ports > Port Data Types'''] ou [ALT]+D+S+D+D+[ENTER] | ||
+ | :* Ative a visualização da cor para indicar os tempos de amostragem sinais ['''Display > Sample Time > Colors'''] ou [ALT]+D+T+C+[ENTER] | ||
+ | |||
+ | * Velocidade de simulação | ||
+ | *Note que se for usado um bloco [https://www.mathworks.com/help/dsp/ref/toaudiodevice.html To Audio Device], a velocidade de simulação será determinada pelo tempo real de amostragem do sistema. | ||
+ | *Para acelerar a simulação é necessário remover ou comentar (''comment out'') os dispositivos de tempo real como o '''To Audio Device''' ou '''[https://www.mathworks.com/help/dsp/ref/fromaudiodevice.html From Audio Device]'''. | ||
+ | *Conforme já mencionado a simulação usando '''frames''' no lugar de '''samples''' também acelera a simulação. Experimente utilizar spf = 1, 2, 256, 1024, e perceba a diferença de velocidade de simulação. | ||
+ | *Tipo de entrada para analisar o filtro. | ||
+ | :*Experimente as entradas senoidais, chirp, random noise e mistura dessas, assim como sinais constantes, e observe os sinais de entrada e saída no DT e DF. | ||
+ | |||
+ | |||
+ | *Exemplo de modelo de um sistema e resultados da simulação | ||
+ | |||
+ | {{fig|AE4.3| Modelagem de um sistema em Simulink |SimulationFilterPSD1.png|800 px|}} | ||
− | + | '''DICAS:''' | |
− | |||
− | |||
− | |||
− | |||
+ | *Fazer a análise no DT e DF para um ruido uniforme (-1 a 1) | ||
+ | {{fig|AE4.4| Análise no DT com fonte de ruído randomico |DTnoiseFilterPSD1.png|400 px|}} | ||
+ | {{fig|AE4.5| Análise no DF com fonte de ruído randomico |DFnoiseFilterPSD1.png|400 px|}} | ||
− | + | *Fazer a análise no DT e DF para um sinal de chirp (0 a 4000Hz) | |
− | + | {{fig|AE4.4| Análise no DT com fonte de chirp |DTchirpFilterPSD1.png|400 px|}} | |
− | + | {{fig|AE4.5| Análise no DF com fonte de chirp |DFchirpFilterPSD1.png|400 px|}} | |
− | |||
− | |||
{{collapse bottom}} | {{collapse bottom}} | ||
+ | ===PROJETO FINAL=== | ||
+ | {{collapse top | expand=true | PF - Projeto, simulação e realização e implementação em VHDL de filtros}} | ||
+ | Em todos os filtros abaixo a especificação será sempre a mesma. Cada equipe deverá utilizar a especificação do Filtro 3 da AE3. Para o filtro FIR poderá ser utilizada a metodologia de projeto de filtros digital FIR com janelas fixas ou janelas ajustáveis ou usando o algoritmo de Park-McCleallan (PM) (APENAS UM DELES). Para o filtro IIR deverão ser seguidas as etapas (a) projeto de um filtro protótipo analógico passa-baixas H(p); (b) transformação em frequência do filtro H(p) -> H(s) (c) conversão do filtro analógico H(s) em digital H(z), usando a transformação bilinear. A aproximação a ser utilizada neste caso pode ser Butterworth, Chebyshev I, Chebyshev II ou Eliptico (Cauer). | ||
− | * | + | {| class="wikitable" border="1" cellpadding="3" cellspacing="0" style="text-align:left; font-size:100%" bgcolor="#efefef" |
− | * | + | ! scope="col" width=30% align="left"| Equipe |
− | : | + | ! scope="col" width=70% align="center"| Filtro |
− | : | + | |- |
− | :PFr - Relatório do | + | | Equipe 1 |
− | : | + | | BP - (<math> f_a </math> = 44100 Hz; <math> f_1 </math> = 1200 Hz; <math> f_2 </math> = 2000 Hz; <math> f_3 </math> = 3000 Hz; <math> f_4 </math> = 3800 Hz; <math> A_p </math> = 1 dB; <math> A_s </math> = 35 dB; <math> G_{topo} </math> = 5 dB) |
+ | |- | ||
+ | | Equipe 2 | ||
+ | | BP - (<math> f_a </math> = 8000 Hz; <math> f_1 </math> = 1200 Hz; <math> f_2 </math> = 2000 Hz; <math> f_3 </math> = 3000 Hz; <math> f_4 </math> = 3800 Hz; <math> A_p </math> = 3 dB; <math> A_s </math> = 40 dB; <math> G_{topo} </math> = 20 dB) | ||
+ | |- | ||
+ | | Equipe 3 | ||
+ | | BP - (<math> f_a </math> = 1000 Hz; <math> f_1 </math> = 150 Hz; <math> f_2 </math> = 200 Hz, <math> f_3 </math> = 300 Hz; <math> f_4 </math> = 380 Hz, <math> A_p </math> = 1 dB, <math> A_s </math> = 40 dB, <math> G_{topo} </math> = 10 dB) | ||
+ | |- | ||
+ | | Equipe 4 | ||
+ | | BP - (<math> f_a </math> = 2000 Hz; <math> f_1 </math> = 150 Hz; <math> f_2 </math> = 200 Hz, <math> f_3 </math> = 300 Hz; <math> f_4 </math> = 380 Hz, <math> A_p </math> = 0.5 dB, <math> A_s </math> = 30 dB, <math> G_{topo} </math> = 0 dB) | ||
+ | |- | ||
+ | | Equipe 5 | ||
+ | | BP - (<math> f_a </math> = 4000 Hz; <math> f_1 </math> = 400 Hz; <math> f_2 </math> = 800 Hz, <math> f_3 </math> = 1000 Hz; <math> f_4 </math> = 1400 Hz, <math> A_p </math> = 3 dB, <math> A_s </math> = 40 dB, <math> G_{topo} </math> = -10 dB) | ||
+ | |} | ||
+ | |||
+ | ;1) Filtro FIR com precisão "infinita" (''floating point'' de 64 bits): | ||
+ | *Converter o filtro para a estrutura simétrica e realizar com elementos básicos | ||
+ | *Simular o filtro no simulink. | ||
+ | *Usar o HDL coder para converter para vhdl em double (real). | ||
+ | *Fazer a simulação do vhdl no Modelsim. | ||
+ | *Analisar os resultados da simulação no simulink, Modelsim com a resposta de frequencia do filtro (freqz ou fvtool ou fdatool). | ||
+ | ;2) Filtro FIR com precisão finita (''fixed point''): | ||
+ | *Faça a quantização dos coeficientes do filtro para ponto fixo, de modo a reduzir ao máximo o número de bits e o hardware necessário para implementar. | ||
+ | *Simular o filtro no simulink. | ||
+ | *Usar o HDL coder para converter para vhdl em sfix (std_logic_vector). | ||
+ | *Fazer a simulação do vhdl no Modelsim. | ||
+ | *Analisar os resultados da simulação no simulink, Modelsim com a resposta de frequencia do filtro (freqz ou fvtool ou fdatool). | ||
+ | ;3) Filtro IIR com precisão "infinita" (''floating point'' de 64 bits): | ||
+ | *Projetar o mesmo o filtro anterior com IIR (de seu escolha), | ||
+ | *Converter para seções de segunda ordem e realizar com com elementos básicos | ||
+ | *Simular o filtro no simulink. | ||
+ | *Usar o HDL coder para converter para vhdl em double (real). | ||
+ | *Fazer a simulação do vhdl no Modelsim. | ||
+ | *Analisar os resultados da simulação no simulink, Modelsim com a resposta de frequencia do filtro (freqz ou fvtool ou fdatool). | ||
+ | ;4) Filtro IIR com precisão finita (''fixed point''): | ||
+ | *Faça a quantização dos coeficientes do filtro para ponto fixo, de modo a reduzir ao máximo o número de bits e o hardware necessário para implementar. | ||
+ | *Simular o filtro no simulink. | ||
+ | *Usar o HDL coder para converter para vhdl em sfix (std_logic_vector). | ||
+ | *Fazer a simulação do vhdl no Modelsim. | ||
+ | *Analisar os resultados da simulação no simulink, Modelsim com a resposta de frequencia do filtro (freqz ou fvtool ou fdatool). | ||
+ | ;5) Comparação dos filtros IIR e FIR: | ||
+ | *Comparar as respostas de frequência (ganho e fase) dos filtros IIR e FIR. | ||
+ | *Comparar a estabilidade dos filtros IIR e FIR a medida que os coeficientes são representados com menos bits. (use o FDAtool) | ||
+ | *Comparar os atrasos de grupo dos filtros IIR e FIR, mantendo eles em paralelo no simulink. (use o time scope). | ||
+ | *Analise o número de elementos do filtro IIR e do FIR, considere que o número de elementos logicos é proporcional a: (Use o relatório do FDAtool ou do HDL coder) | ||
+ | (S) Somador = B, (M) Multiplicador = 2B, (D) Delay = B. | ||
+ | O número de elementos lógicos o hardware será EL_Hw = N_S x B + N_M x 2B + N_D x B. | ||
+ | Multiplicadores por 1, -1, 0, e 2^N não necessitam de hardware para implementação. | ||
+ | |||
+ | ;6) A entrega do Projeto Final será até dia 18/set/2020. O projeto é avaliado nos quesitos: | ||
+ | :PFp - Implementação do projeto; | ||
+ | :PFq - Qualidade das medidas realizadas; | ||
+ | :PFr - Relatório do projeto; | ||
+ | |||
+ | ;Notas: | ||
+ | *[[Limitações do HDL coder]] | ||
+ | {{collapse bottom}} | ||
==Referências Bibliográficas== | ==Referências Bibliográficas== |
Edição atual tal como às 19h15min de 17 de setembro de 2020
Registro on-line das aulas
Unidade 1
Unidade 1 | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|
profile on
profile viewer Execute no Matlab o código abaixo, e analise os 3 filtros implementados através dos seus zeros e polos. Busque tirar conclusões sobre a influência da posição dos polos e zeros (ver o gráfico do plano z) e correlacione com a resposta de frequência em magnitude (gráfico do freqz).
|
Unidade 2
Unidade 2 - Filtros IIR | |||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Na sequência será mostrado como inicialmente projetar o filtro LP protótipo, e depois as transformações em frequência.
%%Definição do filtro
% Definindo os coeficientes do filtro
b = [1 1]; % Numerador
a = [1 1 5]; % Denominador
% Calculando os zeros (raízes do numerador) e pólos (raízes do denominador)
% Método 1 - usando a função tf2zp
[z1,p1,k]=tf2zp(b,a)
% Método 2 - obtendo as raízes
z2 = roots(b);
p2 = roots(a);
zplane(b,a);
%% Obtendo a resposta em frequência
% substitituindo a variável complexa s por jw usando a função freqz
freqs(b,a);
% Usando cálculo simbólico e plotando o gráfico com semilogx
syms s w
H(s) = (s+1)/(s^2 + s + 5);
pretty(H(1j*w))
latex(H(1j*w))
%%
ws = logspace(-2, 1, 1000);
h = H(1j*ws);
subplot(211)
plot(ws,abs(h)); grid on;
%semilogx(ws,abs(h)); grid on;
subplot(212)
plot(ws,angle(h)/pi*180); grid on;
%semilogx(ws,angle(h)/pi*180); grid on;
Os projetos de filtro Butterworth com função de transferência utilizam os polinômios de Butterworth mostrados na tabela a seguir:
INÌCIO DAS AULAS REMOTAS
Para o projeto dos filtros do tipo Chebyshev, são utilizados os polinômios de Chebyshev de primeira ordem, os quais são definidos pela equação trigonométrica: Os dois primeiros polinômios são facilmente calculados como: O cálculo dos demais termos pode ser feita pela relação recursiva: Portanto o polinômio de grau 2 pode ser obtido por Assim os primeiros nove polinômios de Chebyshev de primeira ordem podem ser obtidos: Esses polinômios mostram um comportamento oscilatório entre . FONTE: Polinômios de Tchebychev, Wikipedia
Para o projeto de filtros analógicos é necessário fazer as transformações de frequência indicadas abaixo, as quais devem ser consideradas no momento da determinação dos parâmetros do filtro protótipo LP.
%% Projeto de filtro passa-alta (HP) usando funções do Matlab
Wp = 150; % rad/s
Ws = 40; % rad/s
Rp = 3; % dB
Rs = 60; % dB
[n,Wn] = buttord(Wp,Ws,Rp,Rs,'s')
[b,a] = butter(n,Wn,'high','s');
[h,w] = freqs(b,a,logspace(1,3,1000));
semilogx(w,20*log10(abs(h)));grid on;
hold on; plot([Wp Wn Ws],[-Rp -3 -Rs],'x'); hold off;
title(sprintf('Filtro HP Butterworth, n = %d',n))
%% Projeto de filtro passa-faixa (BP) usando funções do Matlab
Wp = [100 200]; % rad/s
Ws = [50 250]; % rad/s
Rp = 3; % dB
Rs = 40; % dB
[n,Wn] = buttord(Wp,Ws,Rp,Rs,'s');
[b,a] = butter(n,Wn,'s');
freqs(b,a,logspace(1,3,1000))
title(sprintf('Filtro BP Butterworth, n = %d',n))
%% Projeto de filtro passa-baixas usando funções do Matlab
%% Especificações do filtro
Wp =16000; Ws = 20000; Ap = 0.3; As = 20; G0= 3;
% Para analisar o filtro projetado, use fvtool(b,a) para observar plano s, resposta em magnitude, fase e atraso de grupo
%% Butterworth
[n,Wn] = buttord(Wp, Ws, Ap, As,'s')
[b,a] = butter(n,Wn, 's');
%% Chebyshev I
n = cheb1ord(Wp, Ws, Ap, As,'s')
[b,a] = cheby1(n,Ap, Wp, 's');
%% Chebyshev II
n = cheb2ord(Wp, Ws, Ap, As,'s')
[b,a] = cheby2(n,As, Ws, 's');
%% Elliptic - Cauer
[n, Wn] = ellipord(Wp, Ws, Ap, As,'s')
[b,a] = ellip(n,Ap,As, Wn, 's');
fa = 200;
fN = fa/2;
wo = 60/fN; bw = 10/fN;
[b,a] = iirnotch(wo,bw);
fvtool(b,a);
syms z;
N(z) = poly2sym(b,z);
D(z) = poly2sym(a,z);
H(z) = N(z)/D(z);
pretty(vpa(H(z),3))
fa = 8000;
fN = fa/2;
wo = 941/fN; bw = 100/fN;
[b,a] = iirpeak(wo,bw);
fvtool(b,a);
syms z;
N(z) = poly2sym(b,z);
D(z) = poly2sym(a,z);
H(z) = N(z)/D(z);
pretty(vpa(H(z),3))
fa = 8000; fN = fa/2;
fo = 1000; bw = 20/fN;
[b,a] = iircomb(fa/fo,bw,'peak'); % ou use a flag 'notch'
fvtool(b,a);
syms z;
N(z) = poly2sym(b,z);
D(z) = poly2sym(a,z);
H(z) = N(z)/D(z);
pretty(vpa(H(z),3))
|
- Dias 4, 7, 11 e 14 mai
- Parada Pedagógica sem aulas de acordo com a resolução do colegiado do campus de São José.
- Dia 18 mai
- Retorno às ANPs, porém sem aula de acordo com mensagem recebida do chefe do DEPE.
- Foi solicitado que todos alunos se cadastram no workspace da disciplina no SLACK.
- Foi solicitado que todos alunos respondam a uma sondagem sobre as ANPs Volta às aulas não presenciais em tempo de pandemia.
- Resultado das outras enquetes:
- Você gostaria que a UC de PSD29007 tivesse continuidade através de ANPs durante a pandemia do corona virus?
- sim
- █████████████████████████ | 100% (11)
- não
- A que horas começar as aulas?
- 7:30
- ████████ | 33% (3)
- 7:45
- ██████████████ | 56% (5)
- 8:00
- ██ | 11% (1)
- 8:15
- | 0% (0)
Unidade 3
Unidade 3 - Filtros FIR | ||||||||||||||||||||||||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
A determinação da resposta ao impulso do filtro pode ser feita substituindo a entrada por . O resultado é , e portanto a resposta ao impulso tem duração igual ao número de coeficientes N+1 (onde N é a ordem do filtro). Esse é o motivo pelo qual o filtro tem o nome de filtro de resposta ao impulso finita (FIR - Finite Impulse Response). O filtro também recebe nomes como filtro transversal, Filtro não recursivo, filtro de média móvel, e tapped delay filter (torneira com atrasos?). A função de transferência também pode ser descrita como: Algumas vantagens que os filtros FIR tem sobre os IIR: 1. É possível projetar FIR com fase linear, ou seja atraso de grupo constante. Esses filtros são desejáveis na transmissão de sinais digitais.
2. As amostras da resposta ao impulso são os coeficientes do filtros , e portanto não precisam ser calculadas. 3. Os FIR são sempre estáveis pois tem todos os polos na origem. Também é consequência de não ter realimentação. Por isso também não tem ciclo limite que surge nos filtros IIR como resultado da resposta ao impulso de duração infinita associada a representação dos coeficientes e dos sinais com palavras de comprimento finito de bits. 4. O efeito da representação dos coeficientes e dos sinais com palavras de comprimento finito de bits, na resposta de frequência e resposta no domínio do tempo é menor que nos IIR.
Os filtros de fase linear possuem algumas propriedades (respostas em frequência possíveis, distribuição dos zeros em simetria quadrantal), conforme é mostrado a seguir.
N = 10;
bi = 2*(rand(1,N)-0.5)
%% Tipo I - LP, HP, BS, BP
b = [bi (2*rand(1,1)-0.5) flip(bi)];
fvtool(b,1);
%% Tipo II - LP, BP
% tem um zero em -1
b = [bi flip(bi)];
fvtool(b,1);
%% Tipo III - BP
% tem um zero em 1 e -1
b = [bi 0 -flip(bi)];
fvtool(b,1);
%% Tipo IV - BP, HP
% tem um zero em 1
b = [bi -flip(bi)];
fvtool(b,1);
FIR tipo IConsidere o exemplo de um filtro simétrico de ordem par (N=6) Se ele apresenta simetria dos coeficientes , e , temos que: Para obter a resposta em frequência , substituímos . Aplicando a identidade , obtemos que: Portanto a resposta em frequência tem um resposta de magnitude com uma parte real , e uma fase linear igual a , e portanto o atraso de grupo é , que é a metade da ordem N do filtro. Pode-se generalizar este resultado para qualquer filtro simétrico de ordem par: Na qual se percebe que a fase linear é igual a , e portanto o atraso de grupo é , metade da ordem N do filtro. FIR tipo IIConsidere o exemplo de um filtro simétrico de ordem impar (N=5) Se ele apresenta simetria dos coeficientes , e , temos que: Para obter a resposta em frequência: Aplicando a identidade , obtemos que: Portanto a resposta em frequência tem um resposta de magnitude com uma parte real , e uma fase linear igual a , e portanto o atraso de grupo é , que é a metade da ordem N do filtro. Pode-se generalizar este resultado para qualquer filtro simétrico de ordem impar: Na qual se percebe que a fase linear é igual a , e portanto o atraso de grupo é , metade da ordem N do filtro. FIR tipo IIIConsidere o exemplo de um filtro antissimétrico de ordem par (N=6) Se ele apresenta simetria dos coeficientes , , e , temos que: Para obter a resposta em frequência , substituímos . Aplicando a identidade , e que obtemos que: Portanto a resposta em frequência tem um resposta de magnitude com uma parte real , e uma fase linear igual a , e portanto o atraso de grupo é , que é a metade da ordem N do filtro. Pode-se generalizar este resultado para qualquer filtro antissimétrico de ordem par: Na qual se percebe que a fase linear é igual a , e portanto o atraso de grupo é , metade da ordem N do filtro. FIR tipo IVConsidere o exemplo de um filtro antissimétrico de ordem impar (N=5) Se ele apresenta simetria dos coeficientes , e , temos que: Para obter a resposta em frequência: E portanto Portanto a resposta em frequência tem um resposta de magnitude com uma parte real , e uma fase linear igual a , e portanto o atraso de grupo é , que é a metade da ordem N do filtro. Pode-se generalizar este resultado para qualquer filtro antissimétrico de ordem impar: Na qual se percebe que a fase linear é igual a , e portanto o atraso de grupo é , metade da ordem N do filtro. Propriedades dos filtros FIR de fase linearComo mostrado acima, os filtros que exibem simetria ou antissimetria em seus coeficientes (ou resposta ao impulso), apresentam fase linear (ou atraso de grupo constante). Também foi mostrado que o atraso de grupo é igual a N/2 onde N é a ordem do filtro. Foi demonstrado por Rabiner *** que apenas esses quatro tipos de filtro FIR possuem essa característica, portanto pode-se afirma que "Se e somente se o filtro FIR possui coeficientes simétrico ou antisimétricos ele possui fase linear". Em relação a posição dos zeros, é possível verificar que cada zero sobre o circulo unitário produz uma resposta de magnitude nula na frequencia angular correspondente e um salto de fase de . N = 5;
bi = 2*(rand(1,N)-0.5)
b = [bi (2*rand(1,1)-0.5) flip(bi)];
[h,w] = freqz(b,1,'whole');
figure(1);
subplot(421);
plot(w/pi,20*log10(abs(h))); grid on;
xlabel('\omega / \pi'); ylabel ('magnitude - dB');
subplot(423);
plot(w/pi,angle(h)/pi); grid on;
xlabel('\omega / \pi'); ylabel ('fase - rad / \pi');
subplot(425);
plot(w/pi,unwrap(angle(h))/pi); grid on;
xlabel('\omega / \pi'); ylabel ('fase - rad / \pi');
subplot(427); grpdelay(b,1);
xlabel('\omega / \pi'); ylabel ('atraso de grupo - amostras');
subplot(4,2,[2,4,6,8]); zplane(b,1);
xlabel('real'); ylabel ('imaginario');
Também devido a existência (ou não) de zeros em e , que corresponde a frequência de Nyquist , mostramos que a resposta de magnitude nessas frequencias é nula (ou não). Assim os tipos 1, 2, 3 e 4 de filtros FIR resultam em:
Essa característica é importante conhecer antecipadamente pois implicará no número de coeficientes e na escolha do tipo de (anti)simetria. Por exemplo para filtro BS apenas o Tipo 1 pode ser usado. Outra propriedade a ser destacada é em relação aos zeros do filtro. Em primeiro vamos analisar a consequencia da simetria nos coeficientes : fazendo na segunda equação N-n = m, temos que os limites n = 0 -> m = N, e n = N -> m = 0. Com a mesma análise para antissimetria nos coeficientes : Nessas duas equações é possível perceber que se é um zero então também será um zero de . No caso de zeros reais, se temos um zero então também é um zero, exceto se ou . Por outro lado, se todos os coeficientes b(n) do filtro são reais, então os zeros complexos, aparecem em pares complexos conjugados e , e seus reciprocos e também são zeros de . Esse tipo de disposição dos zeros denominamos de simetria quadrantal. FONTE:
Projeto de filtros FIR pelo método da série de FourierUsando a representação dos filtros ideais LP, HP, BP, BS, com frequências de corte e ganho unitário na banda de passagem e ganho zero na banda de rejeição, e considerando que a magnitude das respostas em frequência é uma função periódica em , e conhecendo as equações de síntese e análise de um sinal (ou sistema) onde É possível coeficientes da série de Fourier de filtros ideais: LP, HP, BP, BS
De modo semelhante é possível obter os coeficientes dos filtros HP, BP e BS.
onde sabe-se que , ou seja para e para .
Aplicando a equação de síntese da série obtemos: Note que esta função tem um máximo em , e cruza o zero em , portanto a lagura do lóbulo central é de . Além disso percebe-se que se aumentamos o tamanho da janela retangular (2M+1), a largura do lóbulo central é reduzida proporcionalmente. Ao fazer o "janelamento" dos coeficientes da série de Fourier da resposta em frequência do filtro ideal, estamos multiplicando a série de coeficientes pelo janela retangular , conforme mostra a figura a seguir. Essa multiplicação no domínio do tempo corresponde a uma convolução no domínio da frequência. A qual é mostrada graficamente na figura a seguir.
L = 64;
wvtool(rectwin(L), triang(L), bartlett(L), hann(L), hamming(L), blackman(L), blackmanharris(L), nuttallwin(L));
Use o código abaixo e verifique o efeito das diferentes janelas temporais sobre a magnitude da resposta em frequência, sobre a resposta ao impulso, posição dos zeros no plano z, etc.
N = 32;
wc = 0.5; M = N/2;
CLP = wc*sinc(wc*(-M:M));
bRET = CLP;
bHAM = CLP.*hamming(2*M+1)';
bBLACK = CLP.*blackman(2*M+1)';
fvtool(bRET,1,bHAM,1,bBLACK,1);
legend('rectwin', 'Hamming', 'Blackman');
ylim([-0.1 0.1])
wp = 0.2*pi; Ap = 1 dB; Gp = 0 dB ws = 0.4*pi; As = 40 dB;
ws = 0.4*pi; Ap = 0.2 dB; Gp = 0 dB wp = 0.6*pi; As = 50 dB;
L = 64;
r = 60; % Chebyshev e Tukey
alpha = 3; % Gauss
betha = 8; % Kaiser
nbar = 10; % Taylor
wvtool(kaiser(L,betha), chebwin(L,r), gausswin(L,alpha),tukeywin(L,r), taylorwin(L,nbar,-r));
Para a janela de Kaiser, a estimação do fator e da ordem do filtro são obtidos por:
onde é a atenuação do lóbulo lateral e é a largura da banda de transição em rad/amostra. A janela de Kaiser é definida por:
onde : é a função de Bessel de ordem zero [2] Utilizando o Matlab é possível estimar esses valores utilizando a função kaiserord. Exemplo da obtenção de um filtro passa baixa com , , atenuação de 40 dB na "stopband" %% Calculo do filtro de kaiser, sem ajustes
% Especificaçao
fsamp = 8000;
fcuts = [1000 1500];
Ap = 1;
As = 40;
ftype = 'low';
fN = fsamp/2;
wp = fcuts(1)/fN;
ws = fcuts(2)/fN;
Dw = abs(ws-wp);
% Calculo da janela de Kaiser
beta = 0.5842*(As-21)^0.4+0.07886*(As-21);
n = ceil((As-8)/(2.285*Dw*pi)+1);
Wn = (wp+ws)/2;
wkaiser = kaiser(n+1,beta);
Forma alternativa de projeto usando a função kaiserord fsamp = 8000;
fcuts = [1000 1500];
Ap = 1;
As = 40;
mags = [1 0];
devs = [1-10^(-Ap/20) 10^(-As/20)];
[n,Wn,beta,ftype] = kaiserord(fcuts,mags,devs,fsamp);
wkaiser = kaiser(n+1,beta);
h_fir = fir1(n,Wn,ftype,wkaiser,'noscale');
A partir das especificações do filtro é possível obter um projeto usando a função fir1. Essa função basicamente aplica o método da janela ao filtro ideal especificado pela(s) frequência(s) de corte . h_fir = fir1(n,Wn,ftype,kaiser(n+1,beta),'noscale');
[Hw,w] =freqz(h_fir);
plot(w*fsamp/2/pi,20*log10(abs(Hw)))
title(['Kaiser filter N = ' num2str(n)])
%fvtool(h_fir,1)
Como resultado do projeto a partir das equações de Kaiser é obtido o filtro abaixo: No entanto realizando ajustes tanto do ganho no topo , na largura da banda de transição , e na ordem do filtro , é possível reduzir essa ordem obtendo o filtro abaixo: L = 64;
r = 60; % Chebyshev e Tukey
alpha = 3; % Gauss
betha = 8; % Kaiser
nbar = 10; % Taylor
wvtool(kaiser(L,betha), chebwin(L,r), gausswin(L,alpha),tukeywin(L,r), taylorwin(L,nbar,-r));
Digital Filters with Linear Phase].
fa = 8000;
Ap = 1;
Ar = 40;
fp = 1000;
fr = 1500;
f = [fp fr];
a = [1 0];
dev = [(10^(Ap/20)-1)/(10^(Ap/20)+1) 10^(-Ar/20)];
[n,fo,ao,w] = firpmord(f,a,dev,fa);
b = firpm(n,fo,ao,w);
[h,w] = freqz(b,1,1024,fa);
plot(w, 20*log10(abs(h))); hold on;
plot([0 fr fr fa/2], [Ap/2 Ap/2 -Ar -Ar],':m')
plot([0 fp fp], [-Ap/2 -Ap/2 -(Ar+30)],':m');
ylim([-(Ar+30) Ap/2+10])
|
Unidade 4 - Realização de Filtros
Unidade 4 - Realização de Filtros |
---|
Para exemplificar as diferentes realizações utilizaremos com base um filtro de ordem 4 representado pela função de transferência
Figura 4.1 - Realização de filtros FIR na Forma Direta
Figura 4.2 - Realização de filtros FIR na Forma Transposta Figura 4.3 - Realização de filtros FIR na Forma Transposta
Os filtros FIR de fase linear podem ser com coeficientes simétricos (tipo I e II) ou antissimétricos (tipo III e IV).
Figura 4.4 - Realização de filtros FIR de fase linear Simétrico I
Figura 4.5 - Realização de filtros FIR de fase linear Simétrico II
Figura 4.6 - Realização de filtros FIR de fase linear Antisimétrico III
Figura 4.7 - Realização de filtros FIR de fase linear Antisimétrico IV
Fs = 30000; % Sampling Frequency
Fpass = 12000; % Passband Frequency
Fstop = 13000; % Stopband Frequency
Dpass = 0.01; % Passband Ripple
Dstop = 0.01; % Stopband Attenuation
flag = 'scale'; % Sampling Flag
% Calculate the order from the parameters using KAISERORD.
[N,Wn,BETA,TYPE] = kaiserord([Fpass Fstop]/(Fs/2), [1 0], [Dstop Dpass]);
% Calculate the coefficients using the FIR1 function.
b = fir1(N, Wn, TYPE, kaiser(N+1, BETA), flag);
hFIR = dsp.FIRFilter;
hFIR.Numerator = b;
% Para definir diretamente os coeficientes
realizemdl(hFIR)
% Para definir os coeficientes através de uma matriz de entrada
realizemdl(hFIR,'MapCoeffsToPorts','on');
Figura 4.8 - Separação do filtro IIR H(z) em H1(z) e H2(z)
Figura 4.9 - Realização de filtros IIR na Forma Direta I
Figura 4.10 - Realização de filtros IIR na Forma Direta II
Figura 4.11 - Realização de filtros IIR na Forma Direta II Canônica
Figura 4.12 - Realização de filtros IIR na Forma Transposta I Figura 4.13 - Realização de filtros IIR na Forma Transposta II
Uso do Simulink para processamento de sinais
Para aprender o básico do Simulink recomendo assistir a estes vídeos da Mathworks
edit hdlsetup.m
Figura 5.1 - Divisão HDL_DUT e testbench Figura 5.2 - Subsistema HDL_DUT
hdlsetup('nome_modelo')
cd hdl_prj/hdlsrc/hdlcoder_simple_up_counter/
do HDL_DUT_compile.do
do HDL_DUT_tb_compile.do
do HDL_DUT_tb_sim.do Figura 5.3 - Subsistema HDL_DUT simulado no Simulink Figura 5.4 - Subsistema HDL_DUT simulado no Modelsim
** Note: **************TEST COMPLETED (PASSED)**************
a_sfix = fi(0.1) % 0.1 representado com signed, 16 bits no total com os bits de fração determinados para representar o sinal b_sfix = fi(-0.1) % 0.1 representado com signed, 16 bits no total com 10 bits de fração c_sfix = fi(0.1,1,5,4) % 0.1 representado com signed, 5 bits no total com 4 bits de fração d_sfix = fi(-0.1,1,5,4) % -0.1 representado com signed, 5 bits no total com 4 bits de fração e_sfix = fi(-0.1,0,5,4) % -0.1 representado com unsigned, 5 bits no total com 4 bits de fração => ERRO a_float = 0.1 b_float = -0.1 fi(0:0.3:10,0,8,0) Para observar a precisão da representação mude o formato numérico para format long format hex format short % formato default Experimente com outros números como (10.3 3.25 pi e)
DataMode Type of arithmetic used in quantization. This property can have the following values: fixed — Signed fixed-point calculations float — User-specified floating-point calculations double — Double-precision floating-point calculations single — Single-precision floating-point calculations ufixed — Unsigned fixed-point calculations The default value of this property is fixed. v = -2:0.3:2 q = quantizer('fixed', [5 4]) quantize(q,0.1) quantize(q,pi) quantize(q,v) qu = quantizer('ufixed', [16 4]) quantize(qu,-0.1) quantize(qu,-pi) quantize(qu,v) Note neste caso que a quantidade de bits total e número de casas fracionárias limitam a representação dos números. range(q)
x=-0.2; % Word length = 8, fraction length = 7 q=quantizer([8,7]) range(q) xq=quantize(q,x); binxq=num2bin(q,xq); % Word length = 16, fraction length = 10 q1=quantizer([160 150]) range(q1) xq1 = quantize(q1,x); binxq1=num2bin(q1,xq1); hexxq1=num2hex(q1,xq1); x xq xq1 disp(['x=',num2str(x), ',xq=',num2str(xq), ',bin=', binxq, ',xq1=',num2str(xq1),',bin=', binxq1 ]) format hex xq1 hexxq1 A precisão da representação numérica também varia conforme o numero de bits usados para a parte fracionária. Para saber a precisão (valor correspondente ao bit menos significativo) use a função eps(q). q=quantizer('ufixed', [4,1]); %q=quantizer([4,1],'fixed') % q=quantizer([4,0],'ufixed') % q=quantizer([4,0],'fixed') % q=quantizer([4,-1],'ufixed') % q=quantizer([4,-1],'fixed') tostring(q) range(q) eps(q) xq=quantize(q,x); binxq=num2bin(q,xq); xq binxq
q=quantizer([3 0],'fixed','round','saturate'); quantize(q,0:0.5:16) q=quantizer([3 0],'ufixed','round','saturate'); quantize(q,0:0.5:16) q=quantizer([3 0],'fixed','round','wrap'); quantize(q,0:0.5:16) q=quantizer([3 0],'ufixed','round','wrap'); quantize(q,0:0.5:16) Note a diferença entre estes 4 quantizadores acima.
No caso dos filtros FIR, escolha uma quantidade de bits suficiente para manter a resposta de frequência especificada, ou modifique o filtro visando reduzir o número de bits necessários. No caso dos IIR, utiliza uma estrutura de seções de segunda ordem (SOS) para a implementação dos filtros.
ATUAL
NEXT
|
Avaliações
- Atividades extraclasse
AE1 - Cálculo de uma DFT de comprimento 8 |
---|
|
AE2 - Projeto de Filtro Analógico e Filtro Digital IIR (Entrega e prazos ver Moodle) | ||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
A primeira parte dessa avaliação visa verificar se você conhece a metodologia de projeto de filtros analógicos: (a) projeto de um filtro protótipo analógico passa-baixas H(p); (b) transformação em frequência do filtro H(p) -> H(s), obtendo o filtro LP, HP conforme o tipo de filtro desejado; Nesta avaliação é solicitado que cada equipe realize o projeto de 2 filtros analógicos. Na segunda parte é solicitado que os filtros BP e BS sejam projetados seguindo as etapas (a) projeto de um filtro protótipo analógico passa-baixas H(p); (b) transformação em frequência do filtro H(p) -> H(s) (c) conversão do filtro analógico H(s) em digital H(z), usando a transformação bilinear. Note que nestes casos a frequência de amostragem do sinal e sistema é fundamental no projeto.
|
AE3 - Projeto de Filtro Digital FIR (Entrega e prazos ver Moodle) | ||||||||||||||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Essa avaliação visa verificar se você conhece a metodologia de projeto de filtros digital FIR com janelas fixas, janelas ajustáveis e usando o algoritmo de Park-McCleallan (PM). Nesta avaliação cada equipe deverá realizar o projeto de 2 filtros analógicos usando janela fixa e ajustáveis e todos os 4 filtros usando o PM. Alguns filtros foram modificados em relação a atividade anterior.
Figura AE3.1 - Resposta ao impulso de um filtro digital FIR Figura AE3.2 - Resposta em frequência de 3 filtros passa altas do tipo FIR Figura AE3.3 - Diagrama de polos e zeros de um filtro digital FIR |
AE4 - Simulação de sistemas DSP com Simulink (Entrega e prazos ver Moodle) | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|
Como atividade de estudo realizar a montagem do modelo indicado na figura abaixo e fazer a simulação, usar fa = 8000Hz.
simulink
fa = 8000 % Sampling frequency; Ta = 1/fa % Sample time; spf = 1 % Samples per frame; v1 = 0.2 % Sine amplitude; f1 = 500 % Sine frequency; G = 0.05 % Gain;
Figura AE4.1 - Modelagem da seleção das fontes de sinal
Figura AE4.2 - Modelagem das medições de sinal
Figura AE4.3 - Modelagem de um sistema em Simulink DICAS:
Figura AE4.4 - Análise no DT com fonte de ruído randomico Figura AE4.5 - Análise no DF com fonte de ruído randomico
Figura AE4.4 - Análise no DT com fonte de chirp Figura AE4.5 - Análise no DF com fonte de chirp |
PROJETO FINAL
PF - Projeto, simulação e realização e implementação em VHDL de filtros | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|
Em todos os filtros abaixo a especificação será sempre a mesma. Cada equipe deverá utilizar a especificação do Filtro 3 da AE3. Para o filtro FIR poderá ser utilizada a metodologia de projeto de filtros digital FIR com janelas fixas ou janelas ajustáveis ou usando o algoritmo de Park-McCleallan (PM) (APENAS UM DELES). Para o filtro IIR deverão ser seguidas as etapas (a) projeto de um filtro protótipo analógico passa-baixas H(p); (b) transformação em frequência do filtro H(p) -> H(s) (c) conversão do filtro analógico H(s) em digital H(z), usando a transformação bilinear. A aproximação a ser utilizada neste caso pode ser Butterworth, Chebyshev I, Chebyshev II ou Eliptico (Cauer).
(S) Somador = B, (M) Multiplicador = 2B, (D) Delay = B. O número de elementos lógicos o hardware será EL_Hw = N_S x B + N_M x 2B + N_D x B. Multiplicadores por 1, -1, 0, e 2^N não necessitam de hardware para implementação.
|
Referências Bibliográficas
- ↑ 1,0 1,1 1,2 DINIZ, P. S. R., DA SILVA, E. A. B., e LIMA NETTO, S. Processamento Digital de Sinais: Projeto e Análise de Sistemas. 2. ed. Porto Alegre: Bookman, 2014. 976 p. ISBN 978-8582601235
- ↑ 2,0 2,1 2,2 2,3 2,4 2,5 2,6 2,7 2,8 SHENOI, B. A. Introduction to Digital Signal Processing and Filter Design. 1.ed. New Jersey: John Wiley-Interscience, 2006. 440 p. ISBN 978-0471464822