Embed Size (px)
Citation preview
SISTEMA ELETRO-RESISTIVO BASEADO EM DSP
PARA ESCOAMENTOS GÁS-LÍQUIDO
Laert Ferreira da Silva Neto
Projeto de Graduação apresentado ao Curso de
Engenharia Elétrica da Escola Politécnica,
Universidade Federal do Rio de Janeiro, como
parte dos requisitos necessários à obtenção do
título de Engenheiro Eletricista
Orientador: José Luiz da Silva Neto
Rio de Janeiro
Agosto de 2015
SISTEMA ELETRO-RESISTIVO BASEADO EM DSP
PARA ESCOAMENTOS GÁS-LÍQUIDO
Laert Ferreira da Silva Neto
PROJETO DE GRADUAÇÃO SUBMETIDO AO CORPO DOCENTE DO CURSO DE
ENGENHARIA ELÉTRICA DA ESCOLA POLITÉCNICA DA UNIVERSIDADE
FEDERAL DO RIO DE JANEIRO COMO PARTE DOS REQUISITOS NECESSÁRIOS
PARA A OBTENÇÃO DO GRAU DE ENGENHEIRO ELETRICISTA
Orientador:
_________________________________________________
Prof. José Luiz da Silva Neto, Ph. D.
Examinador:
_________________________________________________
Prof. Juliana Braga Rodrigues Loureiro, D. Sc.
Examinador:
_________________________________________________
Prof. Paulo Laranjeira da Cunha Lage, D.Sc.
Examinador:
_________________________________________________
Prof. Sergio Sami Hazan, Ph.D.
Rio de Janeiro – RJ, Brasil
Agosto de 2015
iii
Silva Neto, Laert Ferreira
Sistema Eletro-Resistivo Baseado em DSP para
Escoamentos Gás-Líquido/ Laert Ferreira da Silva Neto.
– UFRJ/ Escola Politécnica, 2015
xi, 133 p.: il.; 29,7 cm.
Orientador: José Luiz da Silva Neto.
Projeto de Graduação – UFRJ/ Escola Politécnica/
Curso de Engenharia Elétrica, 2015
Referências Bibliográficas: p. 80-81
1. Instrumentação. 2. Sensor Eletro-Resistivo. 3.
Escoamentos Bifásicos. 4. DSP. I. Silva Neto, José Luiz.
II. Universidade Federal do Rio de Janeiro. III Sistema
Eletro-Resistivo Baseado em DSP para Escoamentos
Gás-Líquido
iv
DEDICATÓRIA
Dedico este trabalho a minha amada Andréa Queiroz.
v
Resumo do Projeto de Graduação apresentado à Escola Politécnica/UFRJ como parte
dos requisitos necessários para a obtenção do grau de Engenheiro Eletricista.
SISTEMA ELETRO-RESISTIVO BASEADO EM DSP PARA ESCOAMENTOS
GÁS-LÍQUIDO
Laert Ferreira da Silva Neto
Agosto/2015
Orientador: José Luiz da Silva Neto
Curso: Engenharia Elétrica
A caracterização de escoamentos multifásicos através de ferramentas e
instrumentos adequados, pode conduzir a otimização de processos e sistemas. Assim, o
conhecimento da fração desses fluidos é fundamental para determinação de algumas
propriedades tais como coeficiente de transferência de calor e a perda de carga ao longo
da tubulação.
O sensor eletro-resistivo é capaz de determinar alguns parâmetros do escoamento
bifásico, tais como velocidade e frequência de passagem de bolhas. O princípio básico de
funcionamento do sensor eletro-resistivo é a diferença de resistividade entre o meio
líquido e o gás. Com a passagem do meio líquido, teremos uma menor resistividade e
consequentemente um sinal de nível baixo. Na passagem do gás, teremos uma maior
resistividade e consequentemente um sinal de maior amplitude.
A proposta deste trabalho é criar um instrumento baseado em DSP que execute a
medição, digitalização do sinal, com rejeição de sinais discrepantes, e indique os
resultados em tempo real ao usuário, que, opcionalmente poderá também fazer aquisição
de dados.
Palavras-Chave: Sensor Eletro-Resistivo, DSP, escoamento multifásico
vi
Abstract of Undergraduate Project presented to POLI/UFRJ as a partial fulfillment of
the requirements for the degree of Engineer
ELECTRO-RESISTIVE BASED ON DSP SYSTEM FOR GAS FLOW-NET
Laert Ferreira da Silva Neto
August/2015
Advisor: José Luiz da Silva Neto
Course: Electrical Engineering
The characterization of multiphase flows through appropriate tools and
instruments can lead to optimization of processes and systems. Thus, knowledge of the
fraction of these fluids is critical to determine some properties such as heat transfer
coefficient and pressure loss along the flow.
The electro-resistive sensor is able to determine some parameters of two-phase
flow, such as speed and frequency of bubbles passing. The basic principle of operation of
the electro-resistive sensor is the difference in resistivity between the liquid medium and
the gas. With the passage of liquid medium will have a lower resistivity and thus a low
level signal. The passage of gas, we have a higher resistivity and therefore a sign of greater
amplitude.
The purpose of this work is to create a DSP-based tool that performs
measurement, signal digitization, with rejection of disparate signs, and enter the results
in real time to the user, which optionally can also make data acquisition.
Keyword: Electro-resistive sensor, DSP, multiphase flow
vii
Sumário
1– Introdução .................................................................................................................... 1
1.1 – Motivação ............................................................................................................ 1
1.1.1 – Descrição geral do problema ......................................................................... 1
1.1.2 – Utilização dos Sensores Eletro-Resistivos .................................................... 3
1.2 – Objetivo ............................................................................................................... 3
1.3 – Organização do texto ........................................................................................... 3
2 – Aparato Experimental e apresentação das ferramentas .............................................. 5
2.1 – Ferramentas e equipamentos da Bancada experimental ...................................... 5
2.2 – O Sensor Eletro-Resistivo .................................................................................... 7
2.3 – Circuito Analógico ............................................................................................... 9
2.4 – Comunicação Serial ........................................................................................... 11
2.4.1 – Transmissão Assíncrona .............................................................................. 12
2.4.2 – Transmissão Síncrona ................................................................................. 13
2.5 – O critério de rejeição de Chauvenet ................................................................... 13
2.6 – O critério de Lewis e Davidson (1983) .............................................................. 15
2.7 – Teclado Matricial e Display LCD de caracteres ................................................ 16
2.7.1 – O Teclado Matricial .................................................................................... 16
2.7.2 – O Display de caracteres ............................................................................... 17
2.8 - O DSP F28335 da Texas Instruments .................................................................... 20
2.8.1 – Características Gerais .................................................................................. 20
2.8.4 – Módulo ADC (Analog to Digital Converter) .............................................. 23
2.8.5 - Interface de Comunicação Serial (SCI) ....................................................... 24
2.9 – Shadow Sizer ...................................................................................................... 25
3 – Parâmetros de Projeto ............................................................................................... 27
3.1 – Análise espectral e determinação da frequência de amostragem ....................... 27
3.2 - Filtro Passa Alta Digital .................................................................................... 28
3.2.1 – Função de transferência em tempo contínuo ............................................... 29
3.2.2 - Função de transferência em tempo discreto e equação a diferenças ........... 30
3.3 – Detecções falsas dos sensores Eletro-Resistivos ............................................... 30
3.4 – Algoritmo de Digitalização do sinal e Obtenção de parâmetros ........................ 32
3.5 – Critério de Chauvenet adaptado para operar em tempo real .............................. 35
viii
4 – Utilização das ferramentas e montagem da bancada experimental .......................... 37
4.1 – Programação do DSP F28335 da Texas Instruments ......................................... 37
4.1.1 – Configuração da CPU, Inicialização de periféricos e interrupções ............. 37
4.1.2 – Configuração das entradas ADC ................................................................. 39
4.1.3 – Configuração de GPIO ................................................................................ 42
4.1.4 – Interface de Comunicação Serial (SCI) ....................................................... 45
4.2 – Programa no software CVI para comunicação serial com DSP e aquisição de
dados ........................................................................................................................... 46
4.3 – Dinâmica do funcionamento do medidor eletro-resistivo .................................. 48
4.4 – Montagem da Bancada experimental ................................................................. 49
4.4.1 – Bancada Experimental 1 ............................................................................. 49
4.4.1 – Bancada Experimental 2 ............................................................................. 50
5 – Resultados Obtidos e Validação com Shadow Sizer ................................................ 53
5.1 – Menu de comunicação com o usuário ................................................................ 53
5.2 – Utilização de um sinal com defasagem controlada via D/A da PCI 6014 ......... 57
5.2.1 – Verificação do Período de amostragem ...................................................... 58
5.2.2 – Resultados obtidos para três casos testados ............................................... 58
5.3 – Utilização do microprocessador na Bancada experimental ............................... 62
5.3.1 – Estudo dos tempos associados a execução de códigos ................................ 62
. 5.3.2 – Sinais analógicos e digitais obtidos .................................................... 70
5.3.3 – Validação com o Shadow Sizer ................................................................... 71
6 – Considerações Finais e trabalhos futuros ................................................................. 79
7 –Referências Bibliográficas ......................................................................................... 81
ANEXO 1 – Código utilizado no DSP ........................................................................... 83
A1.1 – Inicialização de Variáveis e funções ............................................................... 83
A1.2 – Função Main ................................................................................................... 86
A1.2.1 – Inicialização de periféricos e configurações gerais .................................. 86
A1.2.2 – Menu de interação com usuário ............................................................... 88
A1.2.3 – Região de alternância com interrupção .................................................... 95
A1.4 – Funções Gerais Utilizadas no código ............................................................ 102
ANEXO 2 – Código utilizado no CVI ......................................................................... 111
ANEXO 3 – Função ADC_isr utilizando o critério de Lewis e Davidson ................... 121
ix
Lista de Figuras
Figura 1 – Padrões de escoamento em dutos horizontais ................................................. 2
Figura 2 - Padrões de escoamento em dutos verticais ...................................................... 2
Figura 3 - Diagrama esquemático do arranjo experimental e o fluxo de dados ............... 5
Figura 4 - Ilustração do sensor Eletro-Resistivo [4] ......................................................... 7
Figura 5 - Sensores eletro-resistivos construídos ............................................................. 8
Figura 6 - Sensores eletro-resistivos em paralelo [5] ....................................................... 9
Figura 7 – Circuito utilizado ............................................................................................. 9
Figura 8 - Transmissão Assíncrona ................................................................................ 12
Figura 9 - Critério de rejeição de Chauvenet .................................................................. 13
Figura 10 - Sinal ideal de detecção de passagem de uma bolha ..................................... 15
Figura 11 - Teclado matricial utilizado .......................................................................... 17
Figura 12 - Display LCD de caractere ............................................................................ 17
Figura 13 - Estrutura interna do F28335 [7] ................................................................... 20
Figura 14 - Diagrama de blocos do GPIO [7] ................................................................ 21
Figura 15 - GPIO organizado por multiplexador [7] ...................................................... 22
Figura 16 - circuito típico de ADCIN [8] ....................................................................... 23
Figura 17 - Câmera NanoSense Mk III, 2080 quadros por segundo a 1.3 mega pixel [6]
........................................................................................................................................ 25
Figura 18 - Fonte de Luz [6] .......................................................................................... 25
Figura 19 - Grandezas mensuradas pelo software “Dynamic Studio” ........................... 26
Figura 20 - DFT do sinal do circuito analógico.............................................................. 27
Figura 21 - Resultado da aplicação do filtro passa alta .................................................. 29
Figura 22 - Problemas relacionados a intrusão do sensor [5] ......................................... 31
Figura 23 – Deformação da frente da bolha gerando altos valores de velocidade ......... 32
Figura 24 - Sinal característico e sua digitalização ........................................................ 33
Figura 25 - Par de sinais ideais ....................................................................................... 33
Figura 26 - sinal digital e seu diferencial ....................................................................... 34
Figura 27 – Esquemático de transição do menu ............................................................. 44
Figura 28 - Modo de transmissão de bytes via porta serial ............................................ 45
Figura 29 - Programa feito em CVI ................................................................................ 46
Figura 30 - mensagem padrão de erro do programa ....................................................... 47
Figura 31 - Dinâmica de funcionamento do medidor eletro-resistivo ............................ 48
Figura 32 - Placa PCI 6014 ............................................................................................ 49
Figura 33 - Diagrama de blocos Simulink ...................................................................... 50
Figura 34 - Aparato experimental ................................................................................... 51
Figura 35 - Circuito analógico montado ......................................................................... 51
Figura 36 - Circuito analógico, DSP, teclado matricial e Display ................................. 52
Figura 37 - Mensagem e entrada do DSP ....................................................................... 53
Figura 38 - Primeiro estágio do menu ............................................................................ 53
x
Figura 39 - segundo estágio do menu ............................................................................. 54
Figura 40 - distância entre sondas .................................................................................. 54
Figura 41 - Configuração de unidades ............................................................................ 55
Figura 42 - Configuração de unidade de velocidade ...................................................... 55
Figura 43 - Unidades de frequência ................................................................................ 56
Figura 44 - Mensagem indicando ausência de sinal na entrada ..................................... 56
Figura 45 - Mensagem indicando cálculo de parâmetros estatísticos ............................ 57
Figura 46 - Resultado indicado na tela do Display ......................................................... 57
Figura 47 - Sinal digital medido pelo osciloscópio ........................................................ 58
Figura 48 - Sinal da sonda e sua digitalização ............................................................... 59
Figura 49 - Sinais digitalizados e defasados ................................................................... 59
Figura 50 - Histograma de velocidade para um sinal defasado de 10 posições ............. 60
Figura 51 - Histograma de velocidade para um sinal defasado de 15 posições ............. 61
Figura 52 - Histograma de velocidade para sinal defasado de 20 posições ................... 61
Figura 53 - Período de amostragem e tempo de execução de instruções ....................... 63
Figura 54 - Período e tempo gasto com instruções versus frequência de bolhas ........... 65
Figura 55 - Frequência de bolhas máxima e tempo gasto com instruções associado ..... 66
Figura 56 - Frequência de bolhas máxima e tempo gasto com instruções associado ..... 67
Figura 57 - Frequência de bolhas máxima e tempo gasto com instruções associado,
sistema 1 por 6 ................................................................................................................ 68
Figura 58 - Tempo gasto em instruções versus período de aquisição ............................ 69
Figura 59 - Período máximo de aquisição de dados ....................................................... 69
Figura 60 - Sinais analógicos das sondas ....................................................................... 70
Figura 61 - Sinais digitais dos sensores .......................................................................... 70
Figura 62 - Sonda 1, construída com agulha de acupuntura e isolada com tinta isolante
........................................................................................................................................ 71
Figura 63 - Sonda 2, construída com fio rígido .............................................................. 72
Figura 64 - Aparato experimental com a câmera e o LED ............................................. 72
Figura 65 - Medição da vazão de injeção de gás por um rotâmetro ............................... 73
Figura 66 - Bolha deformada pelo sensor ....................................................................... 74
Figura 67 - Distribuição de velocidades para a sonda 1 ................................................. 75
Figura 68 - Sonda 2 em contato com uma bolha ............................................................ 75
Figura 69 - Distribuição de velocidades obtidas pelo Shadow Sizer ............................. 77
Figura 70 - Distribuição de velocidades obtidas pelo sensor eletro-resistivo ................ 77
Figura 71 - Distribuição de frequência de bolhas ........................................................... 78
Figura 72 - Esteira de bolhas formada após a passagem de uma bolha de Taylor ......... 78
xi
Lista de Tabelas
Tabela 1 - Critério de Chauvenet .................................................................................... 14
Tabela 2 - Instruções aplicáveis ao display de caractere ................................................ 19
Tabela 3 - Arranjo de pinos GPIO no display ................................................................ 42
Tabela 4 - Arranjo de pinos GPIO no teclado ................................................................ 42
Tabela 5- Dados para cálculo de velocidade pelo Shadow Sizer ................................... 76
1
1– Introdução
1.1 – Motivação
1.1.1 – Descrição geral do problema
O estudo de escoamentos multifásicos possui uma grande importância em
diversos sistemas e setores da indústria (como a produção de energia nuclear, indústria
de alimentos e extração de petróleo) e na validação experimental de modelos teóricos e
simulações.
Estes tipos de escoamentos, que possuem diferentes fases (não necessariamente
diferentes estados físicos da matéria), quando devidamente caracterizados conduzem a
uma otimização de processos e consequentemente elevam a segurança e robustez de um
sistema associado.
Um exemplo que ilustra a importância deste tipo de caracterização é o
resfriamento de reatores nucleares. A água, responsável pela redução de temperatura, é
transportada comumente com a sua fase gasosa, formando um escoamento bifásico. A
garantia do bom desempenho deste processo está diretamente associada as características
do fluido em escoamento (água-ar).
Os escoamentos multifásicos em tubulações podem assumir diferentes formas de
organização das fases. Estas são classificadas de acordo com o arranjo espacial do duto,
vertical ou horizontal. Em geral, em dutos longos podem ocorrer até diferentes padrões
de escoamento dependendo do diâmetro do tubo, razão volumétrica entre fases e
propriedades de fases na região de interesse. O tipo de regime de escoamento está
diretamente relacionado a características como a perda de carga (perda de pressão ao
longo do escoamento) e coeficiente de transferência de calor.
Os padrões de escoamento em tubos horizontais podem ser classificados da
seguinte forma: “estratificado plano”, “bolhas dispersas”, “bolhas alongadas”, “slug” e
“anular”. Na figura 1 podemos ver uma ilustração para cada padrão mencionado.
2
Figura 1 – Padrões de escoamento em dutos horizontais
Os padrões de escoamento em tubos verticais podem ser classificados da seguinte
forma: “bolhas dispersas”, “slug”, “churn” e “anular”. Na figura 2 podemos ver uma
ilustração para cada padrão mencionado.
Figura 2 - Padrões de escoamento em dutos verticais
3
1.1.2 – Utilização dos Sensores Eletro-Resistivos
Uma das formas de se caracterizar escoamentos com mais de uma fase, é a
utilização dos sensores eletro-resistivos. Estes tipos de sensores foram introduzidos no
ano de 1963 por Nassos [1], cujo trabalho tinha o fim de determinar a fração de vazios no
escoamento bifásico de nitrogênio e mercúrio.
Esta técnica é baseada na diferença de resistividade entre as fases em um
escoamento bifásico e é intrusiva ao escoamento, ou seja, pode comprometer a geometria
da bolha no momento da passagem pelo sensor. Porém, independe de acesso óptico ao
escoamento ou das características visuais dos fluidos.
Utilizando um par de sensores paralelos e defasados verticalmente por uma
distância conhecida, podemos determinar não somente o tamanho da corda de bolha e a
frequência de passagem pelos sensores individuais como também a velocidade pelo par
de sensores com defasagem espacial conhecida e defasagem temporal de sinal obtida na
análise e processamento do sinal.
1.2 – Objetivo
O objetivo deste trabalho é criar um instrumento com sensores eletro-resistivos
baseado em DSP que execute a medição, digitalização do sinal, com rejeição de resultados
discrepantes, e indique os valores de velocidade e frequência de passagem de bolhas em
tempo real ao usuário, que, opcionalmente poderá também fazer aquisição de dados. Para
tanto, construiremos uma sonda com um par de sensores defasados verticalmente, um
circuito em ponte de wheatstone e um microprocessador que executará o processamento.
As medições serão feitas em um escoamento bifásico intermitente água-ar, em um
escoamento do tipo slug em um tubo vertical de 1” com a fase líquida em repouso e
injeção de gás.
1.3 – Organização do texto
No capítulo 2 descreveremos o aparato experimental e as ferramentas utilizadas,
tais como a sonda eletro-resistiva, o circuito analógico, o microprocessador utilizado, o
4
Shadow Sizing (Método de Dimensionamento por Sombra), teclado matricial e display de
caracteres. Neste capítulo apresentaremos ainda alguns critérios de rejeição: o critério de
Chauvenet [2], para rejeição estatística de resultados discrepantes e o critério de Lewis e
Davidson [3], que rejeita sinais ruins oriundos de bolhas deformadas pelo sensor.
No capítulo 3 discriminaremos os parâmetros de projeto, algoritmos e estratégias
utilizadas no processamento dos sinais. Neste capítulo, ainda, detalharemos o filtro passa
alta digital utilizado, o critério para escolha de frequência de amostragem, e mostraremos
as características e causas de sinais a serem rejeitados.
No capítulo 4, apresentaremos como foi feita a programação no DSP e como foi
organizada a bancada experimental. No capítulo 5 veremos os resultados obtidos, e os
validaremos através do uso da câmera de alta velocidade e do Shadow Sizer.
5
2 – Aparato Experimental e apresentação
das ferramentas
2.1 – Ferramentas e equipamentos da Bancada experimental
O aparato experimental para construção do medidor de velocidade e frequência
de bolhas é composto pelos seguintes instrumentos e equipamentos:
1- Um tubo de 1” com água em repouso e entrada para injeção de ar;
2- Dois pequenos compressores de ar com ajuste de vazão;
3- Um par de sensores acoplados a uma haste metálica;
4- O circuito analógico;
5- DSP TMS320F28335, da família C2000 da Texas Instruments;
6- Um teclado matricial 1x4 para entrada de dados pelo usuário;
7- Um Display LCD de Caracteres 16x2;
8- Software desenvolvido em CVI para monitoração e aquisição de dados via
comunicação serial com o DSP;
Na figura 3 podemos ver o arranjo experimental e o fluxo de dados.
Figura 3 - Diagrama esquemático do arranjo experimental e o fluxo de dados
6
Como podemos ver na figura 3, dois pequenos compressores de ar, com vazão
ajustável, produzem gás dentro do tubo de 1” de acrílico (com um metro e cinquenta
centímetros de comprimento contendo água em repouso). O regime de escoamento
formado, neste arranjo experimental, é o slug. Este regime é caracterizado por possuir
uma bolha, conhecida como bolha de Taylor, que normalmente é simétrica em relação ao
eixo vertical, tem a forma de um projétil e diâmetro próximo ao da tubulação. Ela é
seguida de pequenas bolhas que, na medida em que aumentamos a vazão de gás, tendem
a se aglomerar.
Os sensores, defasados verticalmente de uma distância dx, percebem a passagem
das bolhas. Cada sensor apresentará uma resistividade em relação a haste metálica que se
apresenta afogada no interior do tubo e servirá de entrada ao seu circuito analógico, que
basicamente conta com uma ponte de Wheatstone, um amplificador de instrumentação e
diodo Zener. Desta forma, cada sinal de tensão servirá de entrada a uma porta ADC
(Analog to Digital Converter) do DSP F28335 da Texas Instruments. O microprocessador
então aplicará o algoritmo de digitalização do sinal, em seguida utilizará o algoritmo de
obtenção dos parâmetros, com rejeição sistemática de sinais oriundos das falhas intrusivas
do sensor (este tema será melhor abordado nas seções seguintes) e rejeição estatística de
resultados discrepantes (critério de Chauvenet). O processador se comunicará com um
pequeno teclado matricial de 1 linha e 4 colunas, e um display LCD de caracteres de 16x2.
Utilizando-se os pinos GPIO (General-Purpose Input/Output), foram
configuradas 4 entradas digitais com sensibilidade de transição para nível lógico baixo e
12 saídas para comunicação paralela com os pinos do display. É oferecido ao usuário um
pequeno menu, dando opções de entrar com distância entre sondas (dx) e as unidades dos
parâmetros medidos (m/s ou mm/s para velocidade e Hz ou RPM para frequência). O
menu é controlado no teclado matricial e observado no display. Este último, ainda, mostra
os resultados das medições feitas em tempo real.
Uma outra opção dada ao usuário é a de fazer aquisição de dados via comunicação
serial utilizando o SCI (Serial Communications Interface) do DSP e monitoramento dos
resultados em um programa dedicado, feito através do software CVI (da National
Instruments). Neste, teremos a possibilidade de gravar os resultados em arquivos na
extensão “.txt” ou “.csv”.
7
2.2 – O Sensor Eletro-Resistivo
O sensor eletro-resistivo é constituído por uma agulha (geralmente de
acupuntura, de 0,3 mm ou 0,5 mm) soldada a um cabo e em seguida revestida com
material isolante e impermeável (teflon, epóxi ou tinta isolante). Apenas a sua ponta fica
descascada, fazendo o contato com o meio. A agulha é presa a uma haste metálica, que
permanece com parte de sua estrutura imersa no meio liquido. Um fio é soldado em sua
estrutura a fim de que a mesma sirva de retorno comum para ambos os sensores. Na figura
4 podemos ver uma ilustração do sensor.
Figura 4 - Ilustração do sensor Eletro-Resistivo [4]
A ponta da agulha deverá ser o mais fina possível, sem comprometer a robustez
da sonda. Quanto maior o diâmetro da agulha utilizada na sonda, maior será a influência
destrutiva do sensor nas bolhas e piores serão os resultados gerados.
Uma das agulhas utilizadas neste projeto é feita de aço inoxidável. Por ser um
material de baixa condutividade, um fio fino de cobre foi soldado da ponta da agulha ao
8
fio integrado ao circuito. Com este procedimento, a resistência do sensor associada ao
meio líquido passou de 6 MΩ para 400 kΩ, em média, de acordo com a medição realizada.
Desta forma, garantimos uma maior diferença de resistência associada entre as fases
líquida (em média 400 kΩ) e gasosa (acima de 20 MΩ) ao mesmo tempo em que
garantimos a não oxidação da ponta da agulha (por ser de aço inoxidável). Na figura 5
podemos ver os sensores construídos, com os cabos trançados e soldados na estrutura da
agulha (ainda sem a aplicação do isolante).
Figura 5 - Sensores eletro-resistivos construídos
A outra sonda utilizada neste projeto é feita com fios rígidos, comumente
utilizados em protoboard: uma das pontas descascadas faz o papel do sensor e a outra
ponta é conectada ao circuito.
Conforme descrito anteriormente, utilizaremos duas sondas paralelas defasadas
de uma distância conhecida. A figura 6 ilustra a disposição paralela dos sensores.
9
Figura 6 - Sensores eletro-resistivos em paralelo [5]
2.3 – Circuito Analógico
O circuito analógico é basicamente composto de duas pontes de wheatstone, dois
amplificadores de instrumentação (INA111) com um passa baixa na entrada, diodo
retificador e diodo zener para proteção da entrada analógica do DSP (limitada em 3 V).
O circuito pode ser visto na figura 7.
Figura 7 – Circuito utilizado
10
Como podemos observar na figura 7, o circuito é energizado por duas baterias de
12 V em série. Um terra virtual foi feito entre os pólos intermediários, gerando uma saída
em 12 V e outra em -12 V. A saída em 12 V é reduzida a 5 V através do regulador de
tensão LM7805. As tensões de 12 e -12 V servirão de alimentação ao amplificador de
instrumentação INA111 e a tensão de 5 V servirá de entrada das pontes de wheatstone.
As resistências “Rsensor1” e “Rsensor2” variam de acordo com a resistividade do meio. Os
valores das demais resistências da ponte foram obtidos experimentalmente. As
resistências R1 e R2 devem ser grandes o suficiente para gerar tensões V1+ e V2+
próxima de zero, quando a sonda estiver no meio líquido e pequenas o suficiente para que
a tensão no momento da passagem da bolha (alta resistência de Rsensor1 e Rsensor2) seja a
maior possível. As resistências R4 e R6, R3 e R12 devem ser responsáveis por equilibrar
as pontes, ou seja, trazer a tensão resultante para próximo de zero quando a sonda estiver
no meio líquido.
Como a entrada do amplificador de instrumentação apresenta alta impedância, as
correntes que circularão por R7, R8, R13 e R14 serão praticamente nulas, a ponto de
desprezarmos a queda de tensão nestes resistores. Assim, portanto, as tensões de entrada
no amplificador de instrumentação serão dadas por:
𝑉1+ = 5 ∗𝑅𝑠𝑒𝑛𝑠𝑜𝑟1
𝑅1+𝑅𝑠𝑒𝑛𝑠𝑜𝑟1 (1)
𝑉1− = 5 ∗𝑅6
𝑅6+𝑅4 (2)
𝑉2+ = 5 ∗𝑅𝑠𝑒𝑛𝑠𝑜𝑟2
𝑅2+𝑅𝑠𝑒𝑛𝑠𝑜𝑟2 (3)
𝑉2− = 5 ∗𝑅12
𝑅3+𝑅12 (4)
Observe que V1+ e V2+ são diretamente proporcionais a resistividade do meio
em que a sonda está inserida, pois dependem de Rsensor1 e Rsensor2. As tensões V1- e V2-
são constantes pois não dependem destas variáveis.
11
Temos ainda, no circuito da figura 7, um filtro passa baixa conforme
recomendação do fabricante do circuito integrado INA111. Analisando-se a disposição
dos capacitores no circuito, chegamos a seguinte equação:
𝑓−3𝑑𝑏 =1
4𝜋𝑅7(𝐶2+𝐶12
) (5)
Este tipo de configuração é importante para garantir a filtragem em caso de
diferença entre os pares de capacitores de 100 pF (C2 e C3, e C5 e C6) que devem ser
iguais.
O amplificador de instrumentação utilizado apresenta o ganho da equação 6
abaixo:
𝐺 = 1 +50𝐾
𝑅𝑔 (6)
Utilizando-se uma resistência Rg de 33 kΩ, teremos que o ganho obtido através
da equação 6 será de 2,52.
Após a passagem pelo amplificador, utilizamos um diodo zener IN4729 e um
diodo IN4148 a fim de limitar a tensão de entrada na porta ADC do DSP de 0 a 2,9 V (3,6
V do Zener menos 0,7 V do IN4148).
As resistências R10 e R16 foram obtidas da seguinte expressão
𝑅10 = 𝑅16 =12𝑉−𝑉𝑧
𝐼𝑧 (7)
Sabendo que Vz vale 3,6 V e Iz, segundo o datasheet do fabricante do IN4729,
vale 1 mA, obtemos que R10 e R16 deverão ser de 8,4 kΩ.
As resistências Rin e Rin2, e os capacitores Cin e Cin2 são utilizados por
recomendação do fabricante do DSP.
2.4 – Comunicação Serial
Comunicação serial é um protocolo de comunicação cuja informação é
transmitida bit a bit. Ela pode ser classificada nos seguintes modos:
12
Simplex: comunicação unidirecional feita apenas do transmissor ao
receptor;
Half-Duplex: A comunicação é bidirecional, ou seja, o transmissor
também é receptor, podendo enviar e receber bits. Porém apenas uma direção pode ser
utilizada por vez;
Full-Duplex: A comunicação é bidirecional e pode ocorrer
simultaneamente.
Quanto ao tipo de transmissão, temos ainda duas classificações: transmissão
assíncrona e transmissão síncrona. As características destes dois tipos de transmissão
serão vistas a seguir.
2.4.1 – Transmissão Assíncrona
Neste tipo de transmissão, a comunicação é feita caractere a caractere, não sendo
necessário sincronismo entre transmissor e receptor. A transmissão não é contínua, ou
seja, existe um estado de repouso do transmissor após enviar um caractere (repouso em
nível lógico alto).
Em transmissões assíncronas normalmente utiliza-se a tabela ASCII como base
de transmissão e recepção do conjunto de bits. Na figura 8 podemos ver uma ilustração
de uma transmissão deste tipo.
Conforme podemos observar na figura 8, uma transmissão de caractere somente
é iniciada após o start bit, que atribui nível lógico zero em um período de tempo após o
estado de repouso (nível lógico alto). Após o start bit, inicia-se a transmissão da cadeia
de bits que formarão o caractere. A quantidade de bits transmitidos por caractere pode ser
previamente escolhida e normalmente varia entre 5 e 8 bits. Após a transmissão do
conjunto de bits, ocorre um bit de paridade (para verificação da consistência da
transmissão feita) e, após, ocorre o bit de parada, onde novamente ocorre a fixação em
Figura 8 - Transmissão Assíncrona
13
nível lógico alto. O intervalo de tempo “T” de transmissão de 1 bit está diretamente
relacionado ao Baud Rate que é a taxa de transmissão em bits por segundo. Desta forma
temos que:
T = (Baud Rate)-1 (8)
2.4.2 – Transmissão Síncrona
Neste tipo de transmissão, a comunicação é feita continuamente, bit a bit. Não
existe estado de repouso e não existe intervalos entre bits ou envio de bits grupo a grupo.
Não entraremos nos detalhes deste tipo de transmissão pois não será utilizado neste
projeto.
2.5 – O critério de rejeição de Chauvenet
O critério de Chauvenet é um método de rejeição de resultados, em um conjunto
n de medições que estatisticamente tem o comportamento da distribuição normal. Desta
forma, os resultados a serem desprezados neste conjunto terão uma probabilidade menor
que 1/2n e, consequentemente, os resultados não desprezados terão uma probabilidade na
faixa de 1-1/2n.
Tomando-se a curva de distribuição normal da figura 9, cuja média é igual a μ e
desvio padrão σ, temos que os resultados bons ocuparão a faixa central cuja área é igual
a (1-1/2n)*100% da área da curva.
Probabilidade = 1 – 1/2n
Cσ Cσ
µ
Dados a serem rejeitados
Figura 9 - Critério de rejeição de Chauvenet
14
Como podemos observar na figura 9, os resultados considerados ruins são aqueles
maiores que a média μ somados de uma constante vezes o desvio padrão ou menores que
a média μ subtraídos de uma constante vezes o desvio padrão. Essa constante “C” varia
de acordo com o número de amostras e pode ser obtida da tabela 1.
Tabela 1 - Critério de Chauvenet
N C
3 1,38
4 1,54
5 1,65
6 1,73
7 1,80
8 1,87
9 1,91
10 1,96
15 2,13
20 2,24
25 2,33
50 2,57
100 2,81
300 3,14
500 3,29
1000 3,48
Portanto, em um conjunto N de amostras, uma medida será considerada
estatisticamente aceitável se estiver na faixa:
𝑚é𝑑𝑖𝑎 − 𝑑𝑒𝑠𝑣𝑖𝑜. 𝑝𝑎𝑑𝑟ã𝑜 ∗ 𝐶 ≤ 𝑎𝑚𝑜𝑠𝑡𝑟𝑎(𝑖) ≤ 𝑚é𝑑𝑖𝑎 + 𝑑𝑒𝑠𝑣𝑖𝑜. 𝑝𝑎𝑑𝑟ã𝑜 ∗ 𝐶, 𝑖 = 1, 2, … 𝑁
(9)
15
onde:
𝑚é𝑑𝑖𝑎 = ∑𝑥(𝑖)
𝑁
𝑁𝑖=1 (10)
𝐷𝑒𝑠𝑣𝑖𝑜 𝑃𝑎𝑑𝑟ã𝑜 = √∑(𝑥(𝑖)−𝑚𝑒𝑑𝑖𝑎)2
𝑁𝑁𝑖=1 (11)
2.6 – O critério de Lewis e Davidson (1983)
O critério de rejeição proposto por Lewis e Davidson [3], baseia-se na integridade
do sinal para aceitação ou rejeição de um sinal associado a passagem de uma bolha pelo
par de sensores. Como a sonda eletro-resistiva é intrusiva então as deformações nas
bolhas, provocadas por essa intrusão, se refletem no sinal associado. Na figura 10
podemos ver um sinal ideal, não deformado, referente a passagem de uma bolha pelos
sensores.
Figura 10 - Sinal ideal de detecção de passagem de uma bolha
O critério de Lewis e Davidson, estabelece dois critérios para aceitação do par de sinais:
1) A largura de pulso detectado pelo sensor 1 deve ser igual ao do sensor 2, ou seja:
tFiA – tFA = tFiB – tFB (12)
2) A defasagem entre a frente do par de sinais deve ser igual a defasagem entre finais,
ou seja:
tFB – tFA = tFiB – tFiA (13)
16
Uma tolerância de 15% pode ser utilizada nas condições acima.
De acordo com o critério, a velocidade de uma bolha pode ser obtida pela seguinte
equação:
𝑉𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑒 =1
2∗ (
𝑑𝑥
tFB – tFA+
𝑑𝑥
tFiB – tFiA) (14)
Na equação 14, dx representa a defasagem espacial entre sensores.
De acordo com Lewis e Davidson [3], o tamanho de uma bolha pode ser obtido
pela seguinte equação:
𝑇𝑎𝑚𝑎𝑛ℎ𝑜 =1
4∗ (
𝑑𝑥∗(tFiA – tFA)
tFB – tFA+
𝑑𝑥∗(tFiB – tFB)
tFB – tFA+
𝑑𝑥∗(tFiA – tFA)
tFiB – tFiA+
𝑑𝑥∗(tFiB – tFB)
tFiB – tFiA ) (15)
Como podemos observar, a equação 15 representa a média aritmética dos
diferentes tamanhos de bolha calculados com base na largura de pulso detectada pela
sonda 1, em função das velocidades obtidas pela diferença entre frentes e finais de bolha
e pela largura de sinal proveniente da detecção pela sonda 2, também em função das
velocidades obtidas pela diferença entre frentes e finais de bolha.
2.7 – Teclado Matricial e Display LCD de caracteres
2.7.1 – O Teclado Matricial
Utilizamos neste projeto um teclado matricial de 4 teclas. Este periférico foi
integrado ao DSP através de 4 entradas digitais. Na figura 11 podemos ver o teclado
utilizado.
17
Figura 11 - Teclado matricial utilizado
No projeto, cada tecla quando pressionada aplica uma transição de nível lógico da
entrada digital correspondente de 1 para 0. Desta forma, cada tecla está associada a uma
entrada e todas elas quando pressionadas comunicam o seu pino a um quinto pino de
ground.
2.7.2 – O Display de caracteres
O display utilizado se baseia no controlador Hitachi HD44780 LCD, que utiliza a
tabela ASCII como padrão de interpretação dos bits de dados e amostragem de caracteres.
Na figura 12 podemos ver o arranjo dos 16 pinos.
Figura 12 - Display LCD de caractere
18
No display, os pinos são enumerados de 1 a 16, da esquerda para a direita. Alguns
não possuem os pinos 15 e 16, responsáveis pelo backlight, possuindo, portanto, apenas
14 pinos. Desta forma, em nosso projeto fizemos as seguintes ligações de pinos:
Pino 1 –ground
Pino 2 –Vcc (5 V)
Pino 3 – Ajuste de Contraste diretamente ligado ao ground
Pino 4 – RS: saída digital do DSP
Pino 5 – R/W: ligado ao ground, habilitando o modo de escrita
Pino 6 – Enable: ligado a uma saída digital do DSP
Pino 7 – D0: ligado a uma saída digital do DSP
Pino 8 – D1: ligado a uma saída digital do DSP
Pino 9 – D2: ligado a uma saída digital do DSP
Pino 10 – D3: ligado a uma saída digital do DSP
Pino 11 – D4: ligado a uma saída digital do DSP
Pino 12 – D5: ligado a uma saída digital do DSP
Pino 13 – D6: ligado a uma saída digital do DSP
Pino 14 – D7: ligado a uma saída digital do DSP
Pino 15 –Back Light +: VCC (5 V)
Pino 16 –Back Light -: ground
Na tabela 2 podemos ver algumas instruções de entrada que serão úteis neste
projeto.
19
A temporização entre um enable on e enable off (na tabela, a transição entre estes
estados foi representada por 0-1-0 conforme variação de nível lógico no pino) para cada
instrução normalmente é de 37 µs, de acordo com o datasheet do fabricante. As únicas
exceções são as instruções de Clear Display (linha 2 da tabela 2) e Cursor Home (linha 3
da tabela 2) cuja temporização é de 1,52 ms.
Para escrever um caractere no display, basta utilizar a correspondente sequência
de bits (que pode ser obtida da tabela ASCII) nos pinos D0-D7, com o RS em nível lógico
1 e respeitando a temporização entre o Enable on e Enable off.
Tabela 2 - Instruções aplicáveis ao display de caractere
20
2.8 - O DSP F28335 da Texas Instruments
2.8.1 – Características Gerais
Os DSPs (Digital Signal Processor) são utilizados em inúmeras aplicações
em engenharia, como controle de motores ou processamento digital de sinais.
Basicamente o DSP é um microprocessador com alta capacidade de processamento e que
é programado de acordo com a necessidade de projeto.
O DSP utilizado neste projeto é o TMS320F28335 da família C2000 da Texas
Instruments. Este possui, entre outras, as seguintes características:
68 KB de memória RAM
512 KB de memória Flash
Até 150 MHz de frequência de CPU
16 canais ADC com resolução de 12 bits e até 80 ns de tempo de conversão
3 SCI (Serial Communications Interface)
Controle de interrupção
88 GPIO
18 canais de PWM
Na figura 13 podemos ver a estrutura interna do DSP.
Figura 13 - Estrutura interna do F28335 [7]
21
Como podemos ver na figura 13, o DSP possui dois barramentos independentes:
o barramento de dados (Data Bus) e o barramento de programa (Program Bus). Esta
característica possibilita a leitura e transferência de dois operandos da memória para a
CPU em um único pulso de clock [12].
Na figura 13 observamos ainda a presença de registradores auxiliares de 32 bits,
registradores de 32 bits para multiplicação e adição em ponto fixo e uma unidade de
hardware de 32 bits chamada “FPU” para cálculos em ponto flutuante.
Em nosso projeto, utilizaremos 2 canais do módulo ADC (de conversão
sincronizada a um ePWM), 14 canais do módulo GPIO (10 saídas e 4 entradas digitais),
e interface de comunicação serial (SCI-A). Faremos a programação na memória Flash.
2.8.2 – GPIO (unidades input e output)
Existem 88 pinos de entrada e saída digitais (I/O) no DSP F28335. Elas estão
organizadas em três portas digitais A,B e C. Cada pino I/O pode ser configurado para fins
diferentes, como por exemplo o PWM, interface de comunicação serial (SCI) ou saída e
entrada digital. Na figura 14 podemos ver o diagrama de blocos correspondente ao GPIO.
Figura 14 - Diagrama de blocos do GPIO [7]
22
Na figura 15 podemos ver o GPIO organizado por multiplexador
Figura 15 - GPIO organizado por multiplexador [7]
Nas linhas abaixo podemos ver os registradores de operação disponíveis.
GPxDIR
Utilizado para definir a direção dos dados, ou seja, se um determinado GPIO será
uma entrada (se igual a 0) ou saída digital (se igual a 1).
GPxCLEAR
Esta é uma máscara utilizada para forçar o pino ao nível lógico baixo (0)
GPxSET
Esta é uma máscara utilizada para forçar o pino ao nível lógico alto (1)
GPxTOGGLE
Esta é uma máscara utilizada para forçar o pino ao nível lógico inverso.
GPxDAT
Esta é uma máscara utilizada para acessar e modificar o nível lógico de um pino.
GPIO Input Qualification:
É utilizado para minimizar ruídos no sinal digital. Este recurso está disponível
somente nos 64 primeiros GPIO.
23
2.8.4 – Módulo ADC (Analog to Digital Converter)
O conversor analógico/digital nos fornece a possibilidade de monitorar,
controlar ou processar sinais de tensão associados a alguma variável que se queira medir.
De uma forma geral, para se converter um sinal analógico em um sinal digital, é
necessário especificar o número de bits de resolução do conversor A/D, podendo ser
utilizada a seguinte relação:
𝑉𝑒𝑛𝑡𝑟𝑎𝑑𝑎 = 𝐷 ∗(𝑉𝑅𝑒𝑓+−𝑉𝑅𝑒𝑓−)
2𝑛−1+ 𝑉𝑅𝑒𝑓− (16)
Na equação 16, temos que D é valor de entrada digitalizado, VRef+ é o maior
valor de tensão que pode ser lido pelo conversor, VRef- é o menor valor de tensão que pode
ser lido e n é o número de bits de resolução do conversor A/D.
No DSP F28335 da Texas Instruments, temos 16 entradas ADC com 12 bits
de resolução, que podem receber tensões de 0 a 3 V e duas unidades Sample And Hold,
que armazenam o sinal que será convertido em um curto tempo com o fim de favorecer a
simultaneidade entre conversões dos canais. Desta forma, para o F28335 podemos
simplificar a equação 16 na equação 17.
𝑉𝑒𝑛𝑡𝑟𝑎𝑑𝑎 = 𝐷 ∗3
4095 (17)
De acordo com a Texas Instruments [8] é recomendada a utilização de um
circuito analógico composto por um amplificador operacional, por possuir baixa
impedância na saída, um resistor Rin, responsável por isolar o ADC do amplificador e um
capacitor Cin, responsável por ajudar a estabilizar o sinal na entrada. Recomenda-se que
o resistor Rin seja de até 100 Ω, e o capacitor Cin seja de 20 a 30 pF. Estes componentes
de circuito foram acrescentados no circuito analógico do projeto e podem ser vistos na
figura 7. Na figura 16 podemos ver o circuito externo recomendado e o interno do
conversor ADC.
Figura 16 - circuito típico de ADCIN [8]
24
No circuito da figura 16 temos que Vps é tensão de resíduo da amostragem
anterior. As chaves S1 e S2 alternam de estado entre si: durante a amostragem a chave S1
fecha, carregando o capacitor de amostragem (CSH, de 1.64 pf) através dos resistores RSW
(de 1 kΩ) e do resistor RIN. O período em que a chave S1 ficará fechada é controlado por
um escalonador do clock do ADC, chamado ACQ_PS.
A fonte de clock do ADC é o clock interno HSPCLK. A maior frequência
de conversão que pode ser utilizada é de 25 MHz (FCLK), porém a Texas Instruments
recomenda que, se não for necessário utilizar uma frequência de conversão tão alta, que
se limite o FCLK em 12,5 MHz, pois um erro de não linearidade pode aparecer na
conversão em taxas maiores.
No ADC, o início de uma conversão pode ocorrer de três formas: por
software, onde devemos inserir nível lógico alto no bit 2 do registrador ADCCTRL 2; por
um sinal externo no pino GPIO/XINT2_ADCSOC; por evento associado a alguma
unidade de PWM.
2.8.5 - Interface de Comunicação Serial (SCI)
A interface de comunicação serial realiza a transmissão e recepção por fios
diferentes (Tx e Rx), em uma comunicação que, como já vimos, é do tipo full duplex. O
DSP pode se comunicar com o computador ou outros dispositivos que utilizem o padrão
NRZ (Non-return-to-zero).
Chamamos de SCICLK o clock correspondente ao SCI. Ele é controlado
pelo LSPCLK e pelo BRR (Baud-Rate Register), que é um registrador de 16 bits utilizado
para configuração da taxa de transmissão. Por default, o LSPCLK vale 37,5 MHz, ou seja,
é o resultado da divisão do SYSCLKOUT por 4, caso não seja configurado. Podemos
calcular o SCICLK a partir da equação 17.
𝑆𝐶𝐼𝐶𝐿𝐾 =𝐿𝑆𝑃𝐶𝐿𝐾
𝐵𝑅𝑅+1 (18)
Na prática, não nos preocuparemos em calcular o SCICLK. Devemos somente
verificar a taxa de transmissão necessária para realizar a comunicação, e em função disso
calculamos o BRR correspondente. Sabendo que um bit ocupa 8 ciclos do SCICLK,
podemos reformular, na equação 19, a equação 18 em função do BRR.
25
𝐵𝑅𝑅 =𝐿𝑆𝑃𝐶𝐿𝐾
𝑇𝑎𝑥𝑎𝑡𝑟𝑎𝑛𝑠𝑚.∗8− 1 (19)
Outros importantes parâmetros de configuração do SCI são o número de bits de
parada e bit de paridade. Podemos ainda utilizar um recurso conhecido como FIFO (First
In, First Out). Os FIFOs armazenam as informações de envio e chegada em buffers,
podendo enviar ou receber até 16 caracteres em uma única interrupção de CPU.
2.9 – Shadow Sizer
O método de dimensão da sombra, o Shadow Sizing, pode executar a medição de
diâmetro e velocidade de bolhas através do uso de uma câmera de alta velocidade e alta
resolução e uma luz difusa. Nas figuras 17 e 18 podemos ver a câmera e a fonte de luz.
Figura 17 - Câmera NanoSense Mk III, 2080 quadros por segundo a 1.3 mega pixel [6]
Figura 18 - Fonte de Luz [6]
26
Para se utilizar o equipamento, devemos dispor o tubo com o escoamento de
interesse entre a câmera e a fonte de luz. Em nosso aparato experimental, como estamos
utilizando um escoamento bifásico água-ar, a fonte de luz irá gerar sombras na passagem
das bolhas, e estas serão captadas pela câmera.
Com o software de nome “Dynamic Studio” de pós processamento das imagens,
somos capazes de definir o contorno das bolhas localizadas no foco da câmera, baseado
na escala de cinza da imagem e assim definir parâmetros associados a bolha como a
velocidade e tamanho. Através da sobreposição de sucessivas imagens, conhecendo o
intervalo de aquisição, o número de quadros de entre duas imagens e a distância obtida
na conversão pixels para milímetro, feita em uma calibração em software, podemos
determinar a velocidade. Na figura 19 podemos ver o software utilizado.
Figura 19 - Software “Dynamic Studio”
27
3 – Parâmetros de Projeto
3.1 – Análise espectral e determinação da frequência de
amostragem
Utilizando-se uma placa de aquisição da National Instruments, a PCI 6014, e
utilizando-se um de seus conversores A/D, fizemos a aquisição do sinal do circuito
analógico referente a uma das sondas. Com este sinal, faremos um dos testes no sistema
utilizando uma defasagem controlada, feita através do software Matlab e em seguida
exportando este mesmo sinal através do conversor D/A desta mesma placa. Com isto,
teremos um valor de referência de velocidade que será proporcional a defasagem aplicada,
vezes a taxa de exportação deste sinal. Desta forma poderemos verificar a resposta do
microprocessador a este sinal, comparando com o valor de referência. Para tanto, é de
grande importância conhecer a região espectral em que se encontra o sinal para definição
da taxa de amostragem do conversor A/D do DSP através do critério de Nyquist. A DFT
do sinal pode ser vista na figura 20.
Figura 20 - DFT do sinal do circuito analógico
28
Conforme podemos observar na figura 20, o espectro do sinal está todo
concentrado na região de baixas frequências. A maior frequência observada nesta análise
espectral foi de 600 Hz. Portanto, utilizando o critério de Nyquist, que diz que para se
obter uma boa reconstrução do sinal a taxa de amostragem deverá ser de no mínimo duas
vezes a maior frequência do espectro, e sabendo que o sinal que será utilizado foi
amostrado a uma frequência de 5 kHz, teremos que a frequência de amostragem do ADC
do DSP deverá estar entre:
2 ∗ 600Hz = 1,2 kHz ≤ fADC
(Limitação inferior dada pelo critério de Nyquist)
e
fADC ≤ 5 kHz
(Limitação superior dada pela frequência de amostragem do sinal que será
utilizado, aplicável somente nos testes de exportação do sinal com defasagem controlada
para observação e comparação com a resposta do DSP).
Desta forma, a frequência de amostragem escolhida para o ADC do F28335 para
realização dos testes com sinal exportado via D/A da placa PCI 6014 foi de 4762 Hz, ou
seja, um período equivalente de 210 µs.
Para a utilização do DSP com as entradas ADC diretamente ligadas ao circuito, a
taxa de amostragem escolhida foi de 10 kHz, ou seja, um período equivalente de 100 µs.
3.2 - Filtro Passa Alta Digital
Um filtro passa alta digital deverá ser utilizado a fim de impedir variações no sinal
a ser processado devido a oscilações de resistividade encontradas na mesma fase (devido
a presença de impurezas que modificam as propriedades químicas do meio) e de eliminar
a componente DC do sinal para facilitar o seu processamento.
29
3.2.1 – Função de transferência em tempo contínuo
O filtro passa alta a ser projetado deverá eliminar a componente DC do sinal.
Desta forma, utilizaremos uma frequência de corte igual a 0,001 Hz em um filtro de
primeira ordem. A função de transferência para este filtro será, portanto:
𝐹(𝑠) =𝑠
𝑠+ 𝑤𝑐=
𝑠
𝑠+0,00628 (20)
Simulando-se este filtro no software “Simulink”, com o sinal da sonda como
entrada, teremos o resultado da figura 21.
Figura 21 - Resultado da aplicação do filtro passa alta
Como podemos observar na figura 21, a componente DC foi completamente
eliminada do sinal.
30
3.2.2 - Função de transferência em tempo discreto e equação a
diferenças
Para realizar a discretização da função de transferência dada pela equação 20,
utilizaremos a equação bilinear (regra de Tustin). A relação entre a variável contínua “s”
e a variável discreta “z” dada por esta regra pode ser vista na equação 21.
𝑠 =2
𝑇0 .
1−𝑍−1
1+ 𝑍−1 (21)
Desta forma, substituindo a equação 20 pela equação 21, tem-se que:
𝐹(𝑧) =2−2𝑧−1
𝑧−1(𝑇0𝜔𝑐−2)+(2+𝑇0𝜔𝑐)=
𝑌(𝑧)
𝑈(𝑧) (22)
Nas equações 21 e 22 temos que T0 é o período de amostragem, 𝜔𝑐 é a frequência
de corte em rad/s, Y(z) é o sinal discretizado de saída e U(z) é o sinal discretizado de
entrada. Aplicando-se a transformada Z inversa da equação 22, sabendo que Y(z)*z-1 =
ytk-1 e Y(z) * constante = constante*ytk (o mesmo é válido para U(z)) teremos a seguinte
equação a diferenças do filtro passa alta, que será implementada em código no DSP:
𝑦𝑡𝑘 =2𝑢𝑡𝑘−2𝑢𝑡𝑘+𝑦𝑡𝑘−1(2−𝑇0𝜔𝑐)
2+ 𝑇0𝜔𝑐 (23)
3.3 – Detecções falsas dos sensores Eletro-Resistivos
Detecções falsas dos sensores eletro-resistivos podem ocorrer tanto na sonda
individual quando no par de sensores. Qualquer detecção que não esteja relacionada a
uma dinâmica intrusiva de pouca influência na geometria do escoamento (no caso da
sonda individual) ou de detecção da mesma bolha por parte das duas sondas é considerada
falsa.
De acordo com [5], em um par de sensores eletro-resistivos podemos encontrar os
seguintes problemas:
a- Deformação da bolha ao aproximar-se da ponta do sensor;
b- Rompimento da bolha ao entrar em contato com a agulha a jusante;
c- Coalescência das bolhas em contato com uma das agulhas;
d- Duas bolhas diferentes atingem as agulhas dos sensores;
e- Deflexão da bolha ao entrar em contato com a agulha a montante;
31
f- Duas pequenas bolhas que viajam próximas encontram cada uma um
sensor diferente.
As situações descritas acima podem ser vistas na figura 22.
Figura 22 - Problemas relacionados a intrusão do sensor [5]
Alguns valores de velocidade muito altos podem surgir devido a intrusão dos
sensores eletro-resistivos. Um caso recorrente é quando o “nariz” da bolha demora a ser
perfurado pelos sensores, gerando nela uma deformação. Quando a perfuração ocorre, a
transição entre líquido e bolha será muito rápida, ou seja, valores muito grandes de
velocidade serão calculados. Na figura 23 podemos ver essa situação descrita.
32
dt pequeno
Figura 23 – Deformação da frente da bolha gerando altos valores de velocidade
Um algoritmo de processamento deve ser capaz de rejeitar os sinais indicados
pelas figuras 22 e 23. Os sinais dos itens “a” até “e” e o sinal da figura 23 podem ser
rejeitados pelo critério de Lewis e Davidson. Os sinais de “a” até “f” e o da figura 23
podem ser rejeitados pelo critério de rejeição estatística de Chauvenet, desde que não
ocorram com grande frequência.
3.4 – Algoritmo de Digitalização do sinal e Obtenção de
parâmetros
O sinal de um sensor eletro-resistivo, proveniente da passagem de uma bolha pela
sonda, precisa ser digitalizado a fim de que se facilite a obtenção dos parâmetros
associados. O sinal característico a ser processado pode ser visto na figura 24.
33
Figura 24 - Sinal característico e sua digitalização
Para efetuar a digitalização do sinal foi utilizado uma referência de comparação
para que, sempre que o sinal ultrapassasse este valor de referência, o sinal lógico passasse
a ser unitário e, caso contrário, zero.
Com o sinal digitalizado, devemos agora obter as informações que o par de sinais
é capaz de fornecer. Na figura 25 podemos ver um par de sinais ideais.
Sabendo-se que o par de sensores está defasado de uma distância dx, podemos
calcular a velocidade da bolha:
Figura 25 - Par de sinais ideais
34
𝑉𝑒𝑙𝑜𝑐𝑖𝑑𝑎𝑑𝑒 =𝑑𝑥
𝑇 (24)
Sabendo o valor da velocidade e o tempo que a bolha leva para atravessar o sensor
(Tbolha), podemos determinar o seu tamanho:
𝑇𝑎𝑚𝑎𝑛ℎ𝑜 =𝑑𝑥
𝑇∗ 𝑇𝑏𝑜𝑙ℎ𝑎 (25)
Para a determinação dos tempos T e Tbolha, a estratégia criada em algoritmo é a
utilização do diferencial do sinal digitalizado, ou seja:
𝑑𝑖𝑓𝑒𝑟𝑒𝑛𝑐𝑖𝑎𝑙(𝑆𝑖𝑛𝑎𝑙_𝑑𝑖𝑔𝑖𝑡𝑎𝑙) = 𝑆𝑖𝑛𝑎𝑙_𝑑𝑖𝑔𝑖𝑡𝑎𝑙(𝑛) − 𝑆𝑖𝑛𝑎𝑙_𝑑𝑖𝑔𝑖𝑡𝑎𝑙(𝑛 − 1) (26)
Desta forma, teremos o sinal da figura 26.
Figura 26 - sinal digital e seu diferencial
Como podemos observar na figura 26, através do sinal digital diferencial podemos
delimitar o instante de início da passagem da bolha como 1 e o instante do fim da bolha
como -1. Desta forma, para calcular os parâmetros da bolha, basta seguir 5 passos:
1) Iniciar contador1 e contador2 quando a sonda 1 apresentar um sinal
diferencial igual a 1.
2) Quando a sonda 2 apresentar sinal diferencial 1, parar o contador1. Sabendo
que T0 é o período de amostragem, teremos que:
a) T = (contador1-1)*T0.
b) Velocidade = dx/T.
35
c) Incrementar um contador3.
3) Quando o sinal diferencial 1 atingir o valor -1 (final da bolha), verificar se o passo
2 realmente aconteceu. Se o passo 2 tiver acontecido:
a) Parar contador2.
b) Tamanho_bolha = (contador2-1)*T0*Velocidade
4) Zerar contadores 1 e 2.
5) Após um período de tempo Tfreq, fazer:
a) Frequencia = contador3/Tfreq.
b) Zerar contador 3.
Observe que, seguindo os 5 passos acima, nós garantimos que:
a) Um sinal que é detectado por um sensor mas não é detectado pelo outro
será rejeitado;
b) O sinal será rejeitado se o sinal da sonda 2 se antecipar em relação ao sinal
da sonda 1.
Desta forma, podemos verificar que apenas falta criar uma rotina de rejeição de
um sinal quando os dois sensores percebem bolhas diferentes na correta ordem de subida
(sensor a montante e sensor a jusante), resultando em valores aleatórios de velocidade.
Para resolver este problema, utilizaremos um critério estatístico que será apresentado na
próxima seção.
3.5 – Critério de Chauvenet adaptado para operar em tempo real
Em nossa aplicação, como estamos tratando os dados em tempo real, precisamos
que o critério de rejeição também funcione em tempo real.
Para utilizar o critério de Chauvenet, explicado na seção 2.5, em tempo real,
faremos os seguintes passos:
1) Consideraremos uma janela de 6 amostras de velocidade da bolha de Taylor.
Dessas primeiras 6 amostras obteremos a média através da equação 10.
2) Depois de obter mais 6 amostras, calcularemos o desvio padrão através da equação
11 com base na primeira média (obtida em “1”) e calcularemos novamente a
média equivalente (destas 6 amostras novas).
36
3) Com a média e desvio padrão, iremos calcular os limites superior e inferior dados
pela equação 9 e tabela 1.
4) A partir deste ponto iremos somente aceitar resultados que estejam dentro dos
limites definidos em (3).
5) Após mais 6 amostras voltar para (2) para recalcular os parâmetros.
6) Se passarem quatro segundos sem que mais nenhuma amostra tenha sido obtida
dentro dos critérios, voltar ao passo 1.
37
4 – Utilização das ferramentas e montagem
da bancada experimental
4.1 – Programação do DSP F28335 da Texas Instruments
Para desenvolvimento do código utilizamos o software Code Composer Studio da
Texas Instruments. Nas seções seguintes descreveremos como foi feita a configuração e
programação da CPU, interrupções, ADC, GPIO e SCI para realização do projeto. O
código utilizado na programação do DSP pode ser visto no Anexo 1.
4.1.1 – Configuração da CPU, Inicialização de periféricos e interrupções
O clock do F28335 é gerado pelo oscilador de cristal em uma frequência de 30
MHz. A opção por utilizar um oscilador de baixa frequência e um circuito PLL para gerar
as demais frequências está relacionada a redução da interferência eletromagnética. Dois
pré-escalonadores de clock são utilizados para configurar a entrada de clock de
periféricos: o High-Speed Clock Pre-scaler (HISPCP), utilizado para escalonar o clock
no ADC e o low-Speed Clock Pre-scaler (LSPCLK) utilizado para escalonar o clock no
SCI, SPI, I2C e McBSP. Quando não configurados, assumem valores default (HSPCLK
= 2 e LSPCLK = 4).
Abaixo temos algumas linhas de código responsáveis pela configuração de
frequência de trabalho da CPU, inicialização de periféricos e configuração de
interrupções presentes no código de projeto, na seção A1.2.1 do Anexo 1, que em seguida
serão comentadas.
InitSysCtrl()
Responsável pela desabilitação do Watchdog; inicialização de clock dos
periféricos e determinação frequência de trabalho da CPU a partir do oscilador de 30
MHZ com os pre-escalonadores “DIV” e “DIVSEL”. Assim a CPU foi configurada a
trabalhar em SYSCLKOUT = 10*30/2 = 150 MHz (DIV = 10 e DIVSEL = 2)
InitSciaGpio();
Inicialização da interface de comunicação serial (SCI)
38
DINT;
Desabilita interrupções
#define ADC_MODCLK 0x3
Esta instrução define o valor da constante pré-escalonadora de clock do periférico
ADC (HSPCLK),
SysCtrlRegs.HISPCP.all = ADC_MODCLK
Aplicação do ADC_MODCLK para configurar o clock do periférico ADC, ou
seja: HSPCLK = SYSCLKOUT/2*ADC_MODCLK = 150/(2*3) = 25.0 MHz
InitPieCtrl();
Instrução que apaga interrupções pendentes e desabilita canais de interrupção
InitPieVectTable()
Instrução que faz com que a memória dos periféricos inicialize em um estado
conhecido. Esses estados iniciais estão na tabela de interrupções disponível no arquivo
DSP2833x_pievect incluída na árvore de projeto. Esta mesma tabela é copiada em uma
variável global chamada pievectable que foi definida através do arquivo
DSP2833x_GlobalVariableDefs.c
InitFlash()
Inicialização da memória flash do DSP
PieVectTable.ADCINT = &adc_isr;
Remapeamento de interrupção para a função Isr contida dentro do código
scia_fifo_init();
Inicialização do SCI FIFO
scia_echoback_init();
Inicialização das configurações utilizadas no SCI
InitAdc();
Inicialização do ADC
EINT;
39
Instrução que habilita interrupções
ERTM;
Macro que habilita interrupções de debug
4.1.2 – Configuração das entradas ADC
Conforme mencionado anteriormente, utilizamos dois conversores A/D de 12 bits
do DSP. Nosso projeto utiliza o mecanismo de interrupção para o ADC: o
microprocessador executa o código presente dentro da função main e de forma
temporizada (sincronizada com um PWM, configurado em código) executa as linhas
presentes na função de interrupção do ADC (de nome adc_isr).
Configuração do ADC na função main
As linhas de configuração ADC, presentes na função main do código da seção
A1.2.1 do Anexo 1 estão explicadas abaixo:
AdcRegs.ADCMAXCONV.all = 0x0001;
Determina o número de canais a serem convertidos. Se igual a zero, teremos
apenas um canal de conversão. Como queremos utilizar dois canais de conversão em
nosso projeto, atribuiremos a instrução em hexadecimal 0x0001 a este registrador.
AdcRegs.ADCCHSELSEQ1.bit.CONV00=0x3;
AdcRegs.ADCCHSELSEQ1.bit.CONV01 = 0x2;
As instruções acima correlacionam o estado ao canal de entrada. Acima,
correlacionamos os estados 0 e 1 (CONV00 e CONV01) as entradas ADCINA3 e
ADCINA2 respectivamente.
40
AdcRegs.ADCTRL2.bit.EPWM_SOCA_SEQ1 = 1;
A instrução acima é uma máscara que habilita a conversão ADC via ePWM.
AdcRegs.ADCTRL2.bit.INT_ENA_SEQ1 = 1;
Habilita o uso de interrupção
EPwm1Regs.ETSEL.bit.SOCAEN = 1;
Habilita o ADC Start of Conversion A (SOCA)
EPwm1Regs.ETSEL.bit.SOCASEL = 4;
Configura o CMPA como evento de mudança de nível lógico do ePWM
EPwm1Regs.ETPS.bit.SOCAPRD = 1;
Gera o pulso de conversão logo no primeiro evento
EPwm1Regs.CMPA.half.CMPA = 0x0080;
CMPA é responsável pela largura do pulso (lembrando que CMPA deve ser
sempre menor que TBPRD)
EPwm1Regs.TBCTL.bit.CTRMODE = 0;
Aqui eu defino meu PWM como sendo do tipo count up
EPwm1Regs.TBPRD = T0*150000000/2;
Aqui eu defino a frequência de PWM. Como nosso PWM é do tipo count up, é
válida a regra: TBPRD = Tpwm * sysclkout / clkdiv*hspclkdiv. Observe que Tpwm é o
mesmo que TADC pois é o PWM quem temporiza a conversão. Desta forma, escolhendo
um intervalo de aquisição de dados definido como T0 (210 µs), sabendo que CLKDIV=1
e HSPCLKDIV = 2 por default e a frequência de CPU (SYSCLkOUT) é igual a
150000000, logo TBPRD = 210*10-6 * 150 *106/2 = 15750
41
Algoritmos de digitalização, detecção e rejeição na função de interrupção ADC
Nesta seção veremos os trechos de código que compõem a função de interrupção
adc_isr(void), presente no código da seção A1.3 do Anexo 1.
Nas linhas de código correspondentes a função adc_isr, temos duas variáveis
inteiras de 16 bits (Voltage1 e Voltage2) associadas aos valores de conversão de 12 bits
do ADC (ADCRESULT0 e ADCRESULT1) que são deslocados de 4 bits a direita para
que o valor de conversão de 12 bits ocupe as primeiras posições da variável de 16 bits.
Em seguida, essa variável inteira é convertida em um float, multiplicando o valor inteiro
pelo maior valor lido pela entrada ADC (3 V) e dividindo pelo maior valor inteiro que
pode ser obtido pelo registrador de 12 bits (212 – 1 = 4095).
As demais linhas de código são responsáveis por associar valores iniciais para as
variáveis utk1 e utk2 que na verdade são as próprias entradas de sinal do ADC. Uma
variável auxiliar (aux4) foi criada para garantir que essas instruções apenas sejam feitas
uma vez. Após isso, a variável que é um vetor de floats com três posições irá se atualizar
de forma cíclica, ou seja, sempre a posição 2 do vetor será a mais atual, a posição 1
corresponderá ao valor anteriormente lido e a posição 0 ao valor lido há dois ciclos atrás.
Nesta mesma função de interrupção, utilizamos as variáveis ytk e ytk2 como saídas
do filtro passa altas, T0 o intervalo de aquisição, wc a frequência de corte utilizada em
rad/s, result e result2 são os valores de sinal digitalizado, dif1 e dif2 são os sinais
digitalizados diferenciais. Observe que aqui vale a mesma regra anterior: os vetores de
posição 2 são os mais atuais, os de posição 1 são os de um ciclo anterior e os de posição
0 são os de 2 ciclos anteriores. Ao final da função de interrupção do ADC essas variáveis
são sempre atualizadas.
Nesta mesma função, utilizamos os algoritmos disponibilizados nas seções 3.4 e
3.5. Como utilizamos uma janela fixa de 6 amostras, o valor de C utilizado é 1,73,
conforme podemos ver na tabela 1. Temos ainda que a variável tsup representa o valor
limitante superior e tinf o valor limitante inferior para aceitação de amostras.
42
4.1.3 – Configuração de GPIO
Conforme já descrito anteriormente, nosso projeto conta com um teclado matricial
e um display de caractere. Os pinos do display de caractere foram ligados em saídas
digitais e os pinos do teclado matricial foram ligados em entradas digitais do DSP. Na
tabela 3 podemos ver como foram ligados os pinos GPIO nos pinos do display.
Tabela 3 - Arranjo de pinos GPIO no display
Na tabela 4 podemos ver como foram ligados os pinos GPIO nos pinos do teclado
matricial.
Tabela 4 - Arranjo de pinos GPIO no teclado
Instruções de configuração dos pinos GPIO
Nas linhas de código da seção A1.2.1 do Anexo 1 podemos ver como os pinos,
disponíveis nas tabelas 3 e 4, foram configurados. Basicamente, utilizamos as seguintes
instruções dispostas abaixo:
GpioCtrlRegs.GP[n]MUX[y].bit.GPIO[x] = 0 : definição do tipo de uso do pino
GPIO. Temos que [n] equivale ao GPIO A, B ou C, [y] equivale ao MUX 1 ou 2
correspondente e [x] o pino GPIO a ser configurado. Se igual a zero, o pino está
configurado como entrada ou saída digital.
Pino GPIO do DSP Pino do Display
GPIO16 D0
GPIO17 D1
GPIO18 D2
GPIO19 D3
GPIO20 D4
GPIO21 D5
GPIO22 D6
GPIO23 D7
GPIO24 RS
GPIO26 ENABLE
Pino GPIO do DSP Pino do Teclado Função
GPIO25 3 Ok
GPIO27 1 Up
GPIO30 2 Down
GPIO31 4 Return
43
GpioCtrlRegs.GP[n]DIR.bit.GPIO[x] = 0 ou 1: definição da direção do fluxo de
dados no pino, ou seja, se é uma entrada ou saída digital. Temos que [n] equivale
ao GPIO A, B ou C e [x] o pino GPIO a ser configurado. Se igual a 1, estamos
configurando o pino como saída digital e se igual a 0, estamos configurando-o
como entrada.
Funções básicas utilizadas nos GPIO
As funções dispostas na seção A1.4 do anexo 1, estão diretamente relacionadas as
portas GPIO utilizadas e serão comentadas abaixo:
Função stri: recebe uma string de entrada e a direciona ao display. Para isso, ela
separa caractere por caractere desta string e do caractere separa bit por bit para ser
associado ao GPIO correspondente ao envio dos dados ao display.
Função fti: recebe um float de entrada e o converte para string. Ela é utilizada para
indicar os resultados no display e para enviá-los via porta serial.
Funções cursor_init_erase, cursor_init, cursor_init_l2, cursor_desloc,
cursor_desliga e cursor_liga : estão associadas às linhas 2,3,12,11 e 9 da tabela
1, respectivamente.
Funções disp_vel e disp_freq: responsáveis por atualizar os resultados de
velocidade e frequência no display e envio serial do conjunto de bytes
correspondente aos resultados.
Menu de Interação com o Usuário
Um menu de interação com o usuário foi criado. Neste, podemos escolher a
unidade a ser utilizada para cada parâmetro (m/s ou mm/s para velocidade e Hz ou RPM
para frequência). Podemos ainda entrar com a distância entre os sensores, para o caso de
se utilizar outros pares de sensores com diferentes defasagens espaciais. O código
responsável pela dinâmica do menu pode ser visto na seção A1.2.2 do Anexo 1.
Basicamente o menu funciona acessando o nível lógico dos registradores de
estado do GPIO. As variáveis Up e Down servem para que o programa não se perca em
relação a posição de cursor definida pelo usuário, mesmo quando o botão correspondente
for pressionado sequencialmente. Se o botão Up é pressionado (ou seja,
GpioDataRegs.GPADAT.bit.GPIO27==0), a variável Up ganha uma ficha e Down a
perde. Se o usuário pressiona o botão Down (ou seja,
44
GpioDataRegs.GPADAT.bit.GPIO30==0), a variável Up perde a ficha e a Down a ganha.
Utilizando a função “goto” eu posso alternar entre um menu e outro pressionando o botão
“return” (voltar ao menu anterior, onde GpioDataRegs.GPADAT.bit.GPIO31==0).
Quando o botão “Ok” é pressionado (ou seja, GpioDataRegs.GPADAT.bit.GPIO25==0)
eu avanço ao menu secundário escolhido ou defino algum parâmetro de interesse.
Na figura 27 podemos ver o esquemático de transição do menu.
Pin
o 1
Pin
o 2
Pin
o 3
Pin
o 4
Pin
o 5
Pin
o 6
Pin
o 7
Pin
o 8
Pin
o 1
0
Pin
o 1
1
Pin
o 1
2
Pin
o 1
3
Pin
o 1
4
Pin
o1
5
Pin
o1
6
Medidor de Bolhas
Eletro-Resistivo
Pin
o 1
Pin
o 2
Pin
o 3
Pin
o 4
Pin
o 5
Pin
o 6
Pin
o 7
Pin
o 8
Pin
o 1
0
Pin
o 1
1
Pin
o 1
2
Pin
o 1
3
Pin
o 1
4
Pin
o1
5
Pin
o1
6
( )Medicao
( )Configuracoes
Pin
o 1
Pin
o 2
Pin
o 3
Pin
o 4
Pin
o 5
Pin
o 6
Pin
o 7
Pin
o 8
Pin
o 1
0
Pin
o 1
1
Pin
o 1
2
Pin
o 1
3
Pin
o 1
4
Pin
o1
5
Pin
o1
6
( )Unidades
( )Dist. Sondas
Pin
o 1
Pin
o 2
Pin
o 3
Pin
o 4
Pin
o 5
Pin
o 6
Pin
o 7
Pin
o 8
Pin
o 1
0
Pin
o 1
1
Pin
o 1
2
Pin
o 1
3
Pin
o 1
4
Pin
o1
5
Pin
o1
6
Dist. Sondas
- 3.0mm +
Pin
o 1
Pin
o 2
Pin
o 3
Pin
o 4
Pin
o 5
Pin
o 6
Pin
o 7
Pin
o 8
Pin
o 1
0
Pin
o 1
1
Pin
o 1
2
Pin
o 1
3
Pin
o 1
4
Pin
o1
5
Pin
o1
6
( )Velocidade
( )Frequencia
Pin
o 1
Pin
o 2
Pin
o 3
Pin
o 4
Pin
o 5
Pin
o 6
Pin
o 7
Pin
o 8
Pin
o 1
0
Pin
o 1
1
Pin
o 1
2
Pin
o 1
3
Pin
o 1
4
Pin
o1
5
Pin
o1
6
( )m/s
( )mm/s
Pin
o 1
Pin
o 2
Pin
o 3
Pin
o 4
Pin
o 5
Pin
o 6
Pin
o 7
Pin
o 8
Pin
o 1
0
Pin
o 1
1
Pin
o 1
2
Pin
o 1
3
Pin
o 1
4
Pin
o1
5
Pin
o1
6
( )Hz
( )Rpm
“↓” + “Ok”
“↓” + “Ok”
“↓”
+ “O
k”
“Ok” “Return” ou “Ok”
“Return” ou “Ok”
“Return” ou “Ok”
“Ok”
“Return”
“Return”
Início de medição“Ok”
Figura 27 – Esquemático de transição do menu
45
4.1.4 – Interface de Comunicação Serial (SCI)
Para a realização da comunicação serial utilizamos a transmissão de bits em um
Baud Rate igual a 9600, sem bit de paridade, 1 bit de stop e 8 bits de dados. Utilizamos
as funções scia_xmit (envio de um caractere via serial) e a função scia_msg presentes no
exemplo SCI_ECHOBACK do software “Code Composer Studio” (Texas Instruments).
O SCICLK foi configurado para 37,5 MHz.
Em nosso projeto, o modo de transmissão dos valores de velocidade e frequência
está esquematizado na figura 28.
V1 V2 V3 V4 V5 F1 F2 F3 F4 F5 a/b
Figura 28 - Modo de transmissão de bytes via porta serial
Na figura 28 podemos observar que são transmitidos 11 bytes a cada envio de
informação: os 5 primeiros se referem ao valor de velocidade, os 5 seguintes se referem
ao valor de frequência e o 11º é o byte responsável por garantir que o programa em CVI
não irá armazenar a mesma informação duas vezes, pois ocorrerá uma alternância entre o
envio do caractere “a” com o caractere “b”, a cada envio de informação. Os caracteres V3
e F3, no caso de a unidade escolhida pelo usuário ser m/s e Hz, respectivamente, serão o
caractere “.”. Neste caso, a informação transmitida será de dois números com duas casas
decimais. O ponto é percebido pelo programa feito no CVI, e ele serve de referência para
indicar a unidade do valor lido, na interface com o usuário. Se a unidade escolhida for
“mm/s” para velocidade ou “RPM” para frequência, teremos que o ponto deixará de
existir e o número correspondente ao valor transmitido nestes 5 caracteres para cada
informação será um inteiro.
46
4.2 – Programa no software CVI para comunicação serial com
DSP e aquisição de dados
Através da ferramenta de criação de programas com interface gráfica em C
(CVI/LABWINDOWS) da National Instruments, criamos um programa para realizar a
comunicação serial e salvar os dados em um arquivo txt ou csv (excel). O usuário tem a
opção de somente fazer aquisição de dados, somente monitorar os resultados (atualizados
em tempo real) pelo programa ou fazer as duas coisas. Na figura 29 podemos ver o
programa criado.
Conforme podemos ver na figura 29, o programa é caracterizado por possuir 4
regiões:
Configurações de porta: nesta região, configuramos a porta serial de entrada do
DSP no computador.
Resultados: nesta área os resultados são atualizados para monitoramento. O
usuário pode optar por desligar a atualização de resultados.
Aquisição de Dados: nesta região o usuário define o nome, extensão (csv ou txt)
e diretório ao qual o arquivo de aquisição de dados será salvo. A aquisição de dados
também é opcional, podendo ser desligada.
Figura 29 - Programa feito em CVI
47
Histograma-Velocidade: esta região corresponde ao histograma, em tempo real,
da distribuição de velocidades ao longo da aquisição de dados. Nesta área podemos ainda
monitorar o maior e menor valor lido e a moda. Como a velocidade das bolhas segue uma
distribuição normal, nosso parâmetro de interesse é a moda, ou seja, o valor com o maior
número de amostras.
O programa retorna ainda uma mensagem de erro, caso o usuário configure
inadequadamente os parâmetros de porta serial, ou a fonte de sinal serial seja removida
do computador. Esta mensagem pode ser vista na figura 30.
Um arquivo de instalação foi criado para que se possa utilizar o programa em
qualquer computador, mesmo que não possua o CVI instalado.
O código correspondente à criação deste programa pode ser visto no anexo 2.
Figura 30 - mensagem padrão de erro do programa
48
4.3 – Dinâmica do funcionamento do medidor eletro-resistivo
A dinâmica de funcionamento do medidor eletro-resistivo pode ser vista no
diagrama de blocos da figura 31.
Início daMedição
Menu de definição
de parâmetros
Preenchimento de 2 condições iniciais para o
filtro passa altas
Digitalização do Sinal
Cálculo dos parâmetros Para 6 amostras, calcular a média
Para mais 6 amostras, calcular a média e desvio
padrão
Para mais 6 amostras, calcular a média e desvio
padrão e os parâmetros do critério de Chauvenet
Envio de resultados ao display
Envio de resultados via comunicação serial
Aux5 = 0overtime
Aux5 = 0
Aux5 = 1
Aux5 = 2
Aux5 = 1
Aux5 = 2
Aux5 = 0
n<2
n≥ 2
Passa-altas
N<6
N=6 N=0
N=0N=6
N=6
Aux5 = 2N=0
Figura 31 - Dinâmica de funcionamento do medidor eletro-resistivo
Na figura 31, temos que “n” representa o número de conversões A/D, “N”
representa o número de bolhas com parâmetros quantificados, overtime é atingido quando
N permanece constante por mais de 4 s e “aux5” é uma variável auxiliar responsável pelas
etapas de cumprimento do critério de rejeição. Após o início da conversão A/D, temos o
preenchimento das condições iniciais do filtro passa alta. Em seguida teremos a
digitalização do sinal e cálculo dos parâmetros. Aqui surgirão 3 etapas sequenciais:
cálculo da média de 6 amostras de velocidades, depois cálculo de média e desvio padrão
49
de mais 6 amostras e por último o cálculo dos limites do critério de Chauvenet e aplicação
destes limites para rejeição de amostras discrepantes. Em caso de overtime, a sequência
associada ao critério de Chauvenet é reiniciada.
4.4 – Montagem da Bancada experimental
Neste projeto, utilizaremos duas bancadas experimentais: a primeira bancada
compreende o envio de um sinal da sonda com defasagem controlada por software via
conversor D/A de uma placa de aquisição de dados da National Instruments (PCI 6014);
a segunda é a bancada descrita na seção 2.1 do capítulo 2, onde realizaremos a medição
da velocidade das bolhas diretamente do aparato.
4.4.1 – Bancada Experimental 1
Para esta bancada utilizaremos a placa de aquisição PCI 6014, que pode ser vista
na figura 32.
Figura 32 - Placa PCI 6014
O conversor A/D da placa PCI 6014, foi utilizado através do software
matlab/simulink. O sinal, armazenado na memória do computador sob uma variável
matlab é chamado no diagrama de blocos simulink e em seguida exportado em uma taxa
de amostragem de 5 kHz. O sinal é defasado através de comandos de manipulação de
50
matrizes na linha de comando do matlab. O diagrama de blocos pode ser visto na figura
33 a seguir.
Figura 33 - Diagrama de blocos Simulink
Utilizando-se as borneiras da placa de Aquisição, fizemos a ligação do sinal de
saída da placa de aquisição para as entradas 2 e 3 do ADC do DSP F28335.
4.4.1 – Bancada Experimental 2
Esta bancada experimental compreende a finalidade deste projeto, que é a
medição da velocidade das bolhas. Esta bancada é formada pelos elementos listados na
seção 2.1 do capítulo 2.
O aparato experimental, ou seja, a estrutura contendo o tubo, os compressores e a
sonda pode ser vista na figura 34.
51
Figura 34 - Aparato experimental
O circuito analógico da seção 2.3, com os componentes projetados soldados pode
ser visto na figura 35.
Figura 35 - Circuito analógico montado
52
O conjunto formado por circuito analógico e baterias, DSP F28335, teclado
matricial e display de caracteres, utilizado neste projeto, pode ser visto na figura 36.
Figura 36 - Circuito analógico, DSP, teclado matricial e Display
53
5 – Resultados Obtidos e Validação com
Shadow Sizer
5.1 – Menu de comunicação com o usuário
O usuário, ao ligar o DSP, que já possui o código em memória Flash, terá a opção
de configuração de alguns parâmetros através de um menu de entrada. Inicialmente o
display mostra a mensagem da figura 37.
Figura 37 - Mensagem e entrada do DSP
Após a mensagem, uma tela de menu será aberta ao usuário, conforme podemos
ver na figura 38.
Figura 38 - Primeiro estágio do menu
Neste primeiro estágio do menu, o usuário tem a opção de iniciar diretamente a
medição, ou realizar as configurações. Para iniciar as medições basta o usuário pressionar
54
o botão número 3 (botão de “ok”). Se o usuário pressionar o botão para baixo (botão 2) e
em seguida pressionar “Ok”, um segundo estágio de menu aparecerá, conforme podemos
ver na figura 39.
Figura 39 - segundo estágio do menu
Se o usuário pressionar o botão para baixo e em seguida pressionar o botão de
“Ok”, abrirá a configuração de distância entre sondas, conforme podemos ver na figura
40. Se o botão referente ao “Return” for pressionado o menu retorna a tela da figura 38.
Figura 40 - distância entre sondas
Pressionando-se o botão UP (botão 1) o usuário incrementa 0,1 mm no valor de
distância entre sondas e Pressionando Down (botão 2), subtrai 0,1 mm do valor de
distância entre sondas, que vai sendo atualizado imediatamente no display. Pressionando
ok, eu associo o valor escolhido a variável “Dx” do código, que representa a distância
entre sensores para cálculo da velocidade. Se nenhuma configuração for feita, a variável
“Dx” assume o valor default de 3 mm.
55
Pressionando-se o botão “Return” (botão 4), eu volto para a tela da figura 39.
Neste ponto, eu posso também selecionar a opção “Unidades” pressionando o “Ok”. Em
seguida, teremos no display as variáveis medidas e que podem ter sua unidade de medida
alterada. Se nenhuma unidade for escolhida, o programa utiliza “m/s” para velocidade e
“Hz” para frequência. Na figura 41 podemos ver este menu no display.
Figura 41 - Configuração de unidades
Conforme podemos ver na figura 41, o usuário pode escolher entre configurar
unidades da velocidade ou frequência. Escolhendo configurar velocidade, teremos a tela
da figura 42.
Figura 42 - Configuração de unidade de velocidade
De acordo com a escolha que faço nesta etapa, eu mudo a forma com que o
resultado se apresentará tanto no próprio display quanto no programa de aquisição serial.
O mesmo ocorre para o que for configurado em unidades de frequência. Na figura 43
podemos ver a tela de configuração de unidades para frequência de bolhas.
56
Figura 43 - Unidades de frequência
Após fazer as devidas escolhas para unidades e distância entre sondas, apertando
o botão “Return”, o usuário deve voltar ao menu primário e lá poderá iniciar as medições
com as devidas configurações feitas.
Ao sair do menu, o programa detectará se existe ou não algum sinal na entrada,
baseado no nível de tensão da entrada ADC do DSP. Se o nível de tensão for zero, então
ele transmitirá a mensagem da figura 44 no display.
Figura 44 - Mensagem indicando ausência de sinal na entrada
Se existir algum sinal de entrada, o programa imediatamente iniciará o processo
de cálculos dos parâmetros estatísticos para rejeição de valores discrepantes. Durante
este processo, a mensagem da figura 45 aparecerá no display.
57
Figura 45 - Mensagem indicando cálculo de parâmetros estatísticos
Logo após obter os parâmetros estatísticos, o display mostrará os resultados da
medição, conforme podemos ver na figura 46.
Figura 46 - Resultado indicado na tela do Display
5.2 – Utilização de um sinal com defasagem controlada via D/A
da PCI 6014
Para realização deste experimento, utilizamos a bancada experimental descrita no
item 4.4.1 do capítulo 4. O sinal será exportado via conversor A/D da placa de aquisição
PCI 6014 em uma taxa de amostragem de 5 kHz. O objetivo deste experimento é verificar
a eficácia do algoritmo de cálculo de velocidade implementado no DSP.
58
5.2.1 – Verificação do Período de amostragem
Para efetuar a verificação do período de amostragem utilizamos um dos pinos de
saída digital do F28335. No início da função de interrupção ADC a saída digital foi
configurada em nível lógico alto e no fim da função de interrupção a saída digital foi
configurada para nível lógico baixo. Com isso podemos ver se o período de amostragem
está adequado com o tempo gasto para executar as instruções dentro da função de
interrupção. Na figura 47 podemos ver o sinal digital medido no osciloscópio.
Figura 47 - Sinal digital medido pelo osciloscópio
Como podemos observar na figura 47, o intervalo de amostragem foi de 210 µs e
o tempo gasto para execução das instruções dentro da função de interrupção (tempo em
que o nível lógico do sinal é 1) foi muito menor do que o período de amostragem.
5.2.2 – Resultados obtidos para três casos testados
Como forma de teste dos algoritmos implementados no DSP, conforme já
explicado anteriormente, utilizamos um sinal real da sonda, armazenado sob uma variável
do software Matlab através de aquisição de dados com o uso da placa PCI 6014 e o
59
software Simulink, defasado por um conjunto de posições controlado, a fim de simular
um sinal ideal.
Na figura 48 podemos ver a digitalização do sinal, medida através de um
osciloscópio.
Figura 48 - Sinal da sonda e sua digitalização
Na figura 49 podemos ver a defasagem aplicada a dois sinais digitalizados,
medidos com um osciloscópio.
Figura 49 - Sinais digitalizados e defasados
60
Neste experimento, testamos 3 defasagens diferentes: 10, 15 e 20 posições. Como
a distância entre sondas é de 3 mm, os valores de referência para velocidade serão de 1,5
m/s, 1,0 m/s e 0,75 m/s respectivamente, visto que o período de amostragem é de 200 µs.
Caso 1- Sinal defasado de 10 posições
Para este primeiro caso, utilizando o programa de aquisição via comunicação
serial feito em “CVI/LabWindows” (apresentado no item 4.2 do capítulo 4) obtivemos o
histograma de distribuição de velocidades da figura 50.
Figura 50 - Histograma de velocidade para um sinal defasado de 10 posições
Observe que a moda estatística (resultado mais vezes observado) foi de 1,5 m/s,
exatamente o valor de referência para a defasagem aplicada. Observe que alguns
resultados de velocidade abaixo do esperado foram encontrados. Isso se deve a
consecutivos travamentos no software simulink que, consequentemente atrasa a
exportação do sinal em alguns momentos.
Caso 2- Sinal defasado de 15 posições
Utilizando-se agora uma defasagem de 15 posições, obtivemos o histograma da
figura 51.
61
Figura 51 - Histograma de velocidade para um sinal defasado de 15 posições
Observe que a moda estatística (resultado mais vezes observado) foi de 1 m/s,
exatamente o valor de referência para a defasagem aplicada. Observe que, assim como no
caso anterior, alguns resultados de velocidade abaixo do esperado foram encontrados
pelos mesmos motivos.
Caso 3- Sinal defasado de 20 posições
Utilizando-se agora uma defasagem de 20 posições, obtivemos o histograma da
figura 52.
Figura 52 - Histograma de velocidade para sinal defasado de 20 posições
Observe que a moda estatística foi de 0,75 m/s, exatamente o valor de referência
para a defasagem aplicada. Observe que, assim como nos casos anteriores, alguns
62
resultados de velocidade abaixo do esperado foram encontrados pelos mesmos motivos
explicados anteriormente.
5.3 – Utilização do microprocessador na Bancada experimental
Neste experimento, utilizaremos a bancada experimental constituída pelos
elementos descritos na seção 2.1. Utilizaremos, ainda, o Shadow Sizer para validação dos
resultados obtidos. Nesta análise, não utilizaremos o critério de Lewis e Davidson para
rejeição de amostras. As sondas ensaiadas apresentaram uma grande influência destrutiva
na geometria das bolhas, sob a forma do problema indicado pela figura 22a. Assim, pelo
critério de Lewis e Davidson, quase todas as amostras seriam rejeitadas. Para contornar
este problema, é necessário que se utilize uma geometria nova para os sensores: as agulhas
devem ser feitas de material de alta condutividade, possuir boa rigidez estrutural (para
não se deformar com a passagem do escoamento) e ser fina o suficiente para deformar o
mínimo possível as bolhas. O código da função de interrupção ADC, referente ao critério
de Lewis e Davidson se encontra no anexo 3 e poderá ser utilizado em trabalhos futuros,
quando se for ensaiar uma geometria de sonda menos destrutiva ao escoamento.
5.3.1 – Estudo dos tempos associados a execução de códigos
Com a finalidade de apresentar as limitações trazidas pela utilização do display
de caractere, comunicação serial e tempo gasto na execução de instruções, faremos nesta
seção um estudo a respeito da limitação de leitura e processamento de resultados em
função da frequência com que as bolhas passam pelos sensores, ou seja, a frequência com
que teremos que processar e indicar os resultados ao usuário. Na figura 53 podemos ver
o período de aquisição e o tempo gasto no processamento dos dados na função de
interrupção do ADC (adc_isr). Para tanto, utilizamos uma das saídas digitais com nível
lógico alto na entrada da função de interrupção e nível lógico baixo na saída desta mesma
função, medidos com um osciloscópio digital.
63
Figura 53 - Período de amostragem e tempo de execução de instruções
Como podemos ver na figura 53, o período de amostragem do conversor A/D do
DSP foi de exatamente 100 µs, conforme projetado. Nesta mesma figura, podemos
observar que o tempo gasto com as instruções presentes na função de interrupção do ADC
foi de 20 µs.
Um resultado, antes de ser apresentado ao usuário através do display e programa
de aquisição serial, precisa passar por algumas etapas que consomem tempo de
processamento. Desta forma, temos uma limitação na frequência com que os resultados
podem aparecer, ou seja, temos uma limitação na frequência de aparecimento de bolhas.
Para o display de caractere, para cada atualização temos um total de 33 instruções
(deslocamento de cursor e escrita). Para cada instrução, conforme recomendado pelo
fabricante do display, temos um atraso de 37 µs. Desta forma, o tempo total gasto para
disponibilizar um resultado no display é de 33x37 µs = 1,221 ms.
Para a transmissão via porta serial, teremos o total de envio de 110 bits (1 bit de
start, 8 bits de caractere e 1 bit de stop, sem bit de paridade e o envio de 11 caracteres por
resultado calculado). Desta forma, utilizando um Baud Rate de 9600 teremos um tempo
de 11,45ms gastos com o envio dos caracteres.
Nesta análise, devemos ainda considerar o tempo total gasto em todas as vezes em
que houve entrada na função de interrupção do ADC, entre a atualização de um resultado
e outro. O tempo total gasto com execução de todas estas instruções, que chamaremos de
64
ti deve ser menor do que o período de bolhas, que será nosso período de atualização de
resultados. Desta forma, teremos que:
𝑡𝑖 =𝑁𝑢𝑚𝑏𝑖𝑡𝑠
𝐵𝑎𝑢𝑑 𝑅𝑎𝑡𝑒+ 𝑇𝑑𝑖𝑠𝑝𝑙𝑎𝑦 ∗ 𝑁𝑖𝑛𝑠𝑡𝑟𝑢çõ𝑒𝑠 +
𝑇𝐴𝐷𝐶
𝑓𝑏𝑜𝑙ℎ𝑎𝑠∗𝑇0<
1
𝑓𝑏𝑜𝑙ℎ𝑎𝑠 (27)
Na equação acima temos que “Numbits” é o número de bits transmitidos por
atualização de resultados na comunicação serial, “Baud Rate” é o Baud Rate utilizado na
transmissão, “Tdisplay” é o tempo de delay a ser utilizado por instrução no display de
caractere, “Ninstruções” é o número de instruções utilizadas por atualização de resultados,
TADC é o tempo gasto em instruções de código dentro da função de interrupção ADC,
“fbolhas” é a frequência de passagem de bolhas e T0 é o período de aquisição de dados.
Podemos simplificar a equação 27 na equação 28.
𝑡𝑖 = 11,45𝑚𝑠 + 1,221𝑚𝑠 +20𝜇𝑠
𝑓𝑏𝑜𝑙ℎ𝑎𝑠∗𝑇0<
1
𝑓𝑏𝑜𝑙ℎ𝑎𝑠 (28)
Frequência de bolhas máxima para disposição de resultados um a um
Fixando-se o período de aquisição T0 em 100 µs, podemos levantar a curva de
tempo gasto com instruções em função da frequência de bolhas, e período de bolhas em
função da frequência. Este gráfico pode ser visto na figura 54.
65
Figura 54 - Período e tempo gasto com instruções versus frequência de bolhas
A interseção das curvas da figura 54 nos dará a máxima frequência de bolhas
admitida para um sistema com disposição de resultados um a um, sem que haja corrupção
das informações na transmissão de dados e disposição de resultados no display. Vale
ressaltar que as funções de transmissão ocorrem em segundo plano, na função main, por
questões de otimização da taxa de aquisição do conversor A/D do F28335. A interseção
entre as curvas pode ser vista na figura 55.
66
Figura 55 - Frequência de bolhas máxima e tempo gasto com instruções associado
Desta forma, como podemos ver na figura 55, para este sistema a maior frequência
de bolhas admitida é de 63,09 Hz com um tempo máximo gasto em instruções de 15,85
ms.
Frequência de bolhas máxima para disposição de resultados um por seis
Este método de disposição de resultados que chamamos de “um por seis” foi o
escolhido para operar em nosso sistema. Nele, dispomos os resultados de velocidade
referentes a média para cada 6 bolhas. Os resultados de frequência são calculados em
função do tempo gasto na obtenção destas 6 amostras de velocidade (que corresponderia
ao aparecimento de 6 bolhas). Fixando-se o período de aquisição T0 em 100 µs, podemos
levantar a curva de tempo gasto com instruções em função da frequência de bolhas, e
período referente a 6 bolhas em função da frequência. Este gráfico pode ser visto na figura
56.
67
Figura 56 - Frequência de bolhas máxima e tempo gasto com instruções associado
A interseção entre as curvas da figura 56 nos dará a frequência de bolhas máxima
admitida para um sistema com disposição de resultados um por seis, sem que haja
corrupção das informações na transmissão de dados e disposição de resultados no display.
A opção por utilizar uma frequência admissível de passagem de bolhas tão alta está
relacionada a confusão gerada no sistema de contagem de bolhas pela passagem de uma
esteira de pequenas bolhas, que geram falsos valores elevados de frequência. Na figura
57 podemos ver o ponto de interseção das curvas da figura 56.
68
Figura 57 - Frequência de bolhas máxima e tempo gasto com instruções associado, sistema 1 por 6
Desta forma, como podemos ver na figura 57, para este sistema a maior frequência
de bolhas admitida é de 447,5 Hz com um tempo máximo de 13,41 ms gastos com as
instruções correspondentes.
Intervalo de aquisição máximo para obtenção de uma frequência de bolhas de até
447,5 Hz
Nesta análise, apresentaremos uma alternativa para obtenção da mesma
frequência máxima admissível de bolhas do item anterior em um sistema um por um,
como referência para trabalhos futuros. Para tanto, utilizaremos o maior Baud Rate
possível, ou seja, 115500 bits/s e fixaremos a frequência máxima de bolhas em 447,5 Hz.
Verificaremos qual o intervalo de amostragem mínimo que pode ser utilizado. Na figura
58 podemos ver a curva do tempo gasto com instruções em função do período de
amostragem.
69
Figura 58 - Tempo gasto em instruções versus período de aquisição
O ponto marcado com um ‘*’ na figura 58 representa o período de aquisição
máximo que pode ser utilizado no conversor A/D do F28335. O valor associado a este
ponto pode ser visto na figura 59.
Figura 59 - Período máximo de aquisição de dados
Desta forma, conforme podemos observar na figura 59, o menor período de
aquisição para obtenção da máxima frequência de bolhas admissível de 447.5 Hz é de
790 µs. Um maior período entre conversões A/D significa um maior erro associado na
medição realizada.
70
. 5.3.2 – Sinais analógicos e digitais obtidos
Utilizando-se um osciloscópio digital medimos as saídas do circuito analógico,
conforme podemos ver na figura 60.
Figura 60 - Sinais analógicos das sondas
Utilizando-se duas saídas digitais do F28335, medimos o sinal digitalizado através
de um osciloscópio digital. Estes sinais podem ser vistos na figura 61 abaixo.
Figura 61 - Sinais digitais dos sensores
71
Como podemos ver na figura 61, o sinal do sensor a montante é sempre maior do
que o do sensor a jusante. Isso ocorre devido a influência destrutiva da intrusão dos
sensores.
5.3.3 – Validação com o Shadow Sizer
Nesta etapa de validação com o Shadow Sizer, utilizamos duas sondas em dois
ensaios diferentes. A primeira sonda foi construída com agulhas de acupuntura de 0,3mm
e revestida com tinta isolante. A segunda sonda foi feita com fio rígido, utilizado
comumente em protoboard, deixando duas pontas em contato com o meio, e as outras
duas pontas ligadas ao circuito analógico. Nesta sonda, o retorno do circuito também era
feito por uma haste de aço inoxidável. Ambas as sondas apresentavam sensores defasados
de 3mm, medidos com uma régua com precisão de 0,5 mm. Os sensores construídos
podem ser vistos nas figuras 62 e 63.
Figura 62 - Sonda 1, construída com agulha de acupuntura e isolada com tinta isolante
72
Figura 63 - Sonda 2, construída com fio rígido
Para efetuar as medições com o Shadow Sizer, utilizaremos o LED, um anteparo
para difusão da luz e uma câmera. Entre a câmera e o LED colocaremos a estrutura com
o tubo com água e a sonda, conforme podemos ver na figura 64 abaixo.
Figura 64 - Aparato experimental com a câmera e o LED
73
Para medição da velocidade de subida das bolhas, utilizamos o software
“Dynamic Studio”. Neste, inicialmente fazemos uma calibração de sistemas de pixels
para sistema métrico a partir de dois pontos com distância conhecida. A partir de então,
basta definir um intervalo de aquisição e um número total de quadros desejado. Para obter
os valores de velocidade basta verificar a distância percorrida pela bolha em um intervalo
de tempo dado número de quadros entre as posições vezes o intervalo de aquisição.
Em nosso experimento, utilizamos uma mesma vazão de injeção de gás, de
aproximadamente 12 l/min para os ensaios com as duas sondas. Esta vazão foi medida
com um rotâmetro (medidor de vazão de gás), conforme podemos ver na figura 65.
Figura 65 - Medição da vazão de injeção de gás por um rotâmetro
Em nosso procedimento experimental, o início da aquisição de resultados pelo
programa de aquisição serial precedia o de aquisição pelo Shadow Sizer e sempre
terminava depois, a fim de maximizar o número de amostras. Nesta análise, estaremos
interessados em comparar a moda estatística entre os resultados obtidos pela câmera com
os resultados obtidos pelo sensor eletro-resistivo.
Nas duas seções a seguir veremos os resultados obtidos pelas duas sondas
utilizadas.
74
Resultados obtidos com a Sonda 1
A sonda 1, que pode ser vista na figura 62, apresentou uma característica
amplamente destrutiva ao escoamento. O intuito de se apresentar os resultados obtidos
utilizando esta sonda é mostrar como a geometria do sensor utilizado pode influenciar
diretamente os resultados obtidos. Na figura 66 podemos ver uma bolha, capturada pela
câmera, completamente deformada após passar pelo sensor.
Figura 66 - Bolha deformada pelo sensor
As velocidades obtidas pelo Shadow Sizer para este experimento imediatamente
antes de as bolhas passarem pelos sensores variavam de 0.26 a 0.33 m/s. A distribuição
das velocidades obtidas pelo sensor e indicadas no programa de aquisição serial pode ser
vista na figura 67.
75
Figura 67 - Distribuição de velocidades para a sonda 1
Como podemos ver na figura 67, a deformação provocada pelo sensor nas bolhas
fez com que o resultado obtido, uma moda de 0,12 m/s, estivesse muito abaixo do
resultado esperado. Isso ocorre devido ao atraso gerado pelo sensor a montante na
passagem da bolha pelo mesmo. Para resolver este tipo de problema devemos construir
um sensor de geometria menos intrusiva, com agulhas e recobrimento isolante mais finos.
Resultados obtidos com a Sonda 2
A sonda 2, de geometria mais simples e mais eficaz do que a sonda 1 foi construída
com finos fios rígidos com a ponta descascada em contato com o escoamento. Na figura
68 podemos ver a baixa deformação de uma bolha na passagem por este sensor.
Figura 68 - Sonda 2 em contato com uma bolha
76
No software “Dynamic Studio”, utilizamos uma taxa de amostragem de 50 Hz e
um valor total de 1.000 quadros, resultando em uma aquisição em 20 segundos. Após a
aquisição, o número total de bolhas de Taylor foi contado, totalizando 22. Desta forma, a
frequência de passagem de bolhas de Taylor para estas condições experimentais foi de
1.1 Hz. Os resultados obtidos nesta aquisição podem ser vistos na tabela 5.
Tabela 5- Dados para cálculo de velocidade pelo Shadow Sizer
Na figura 69 podemos ver a distribuição das velocidades através de um
histograma.
Frame 1 Altura 1 (mm) Frame2 Altura 2 (mm) Tempo (s) Velocidade (m/s)
3 40,88 5 66,95 0,04 0,65
33 40,17 37 65,7 0,08 0,31
111 36,96 117 73,91 0,12 0,30
157 38,92 163 79,09 0,12 0,33
233 39,1 240 81,59 0,14 0,30
272 34,28 278 73,73 0,12 0,32
329 52,67 336 83,55 0,14 0,22
357 47,13 359 71,77 0,04 0,61
414 40,17 421 82,84 0,14 0,30
484 35,71 491 81,41 0,14 0,32
522 35,53 528 81,95 0,12 0,38
561 35,89 567 73,02 0,12 0,30
602 41,06 606 77,13 0,08 0,45
656 39,46 662 76,41 0,12 0,30
702 35,53 708 76,06 0,12 0,33
752 37,67 759 83,02 0,14 0,32
803 40,88 809 81,41 0,12 0,33
850 36,42 857 82,66 0,14 0,33
883 44,45 885 72,13 0,04 0,69
923 34,64 930 79,45 0,14 0,32
968 55,35 972 79,63 0,08 0,30
77
Figura 69 - Distribuição de velocidades obtidas pelo Shadow Sizer
Na figura 70 podemos ver a distribuição de velocidades obtidas pelo sensor
eletro-resistivo.
Figura 70 - Distribuição de velocidades obtidas pelo sensor eletro-resistivo
Como podemos observar nas figuras 69 e 70 a distribuição das velocidades do
sensor eletro-resistivo foi muito parecida com a distribuição das velocidades obtidas pelo
Shadow Sizer. A moda de velocidade obtida pelo sensor Eletro-Resistivo foi exatamente
a mesma moda de velocidade obtida pelo Shadow Sizer, de modo que os resultados de
velocidade apresentados pelo sensor construído podem ser considerados bons.
78
O histograma referente a frequência de bolhas pode ser visto na figura 71. Temos
que cada valor amostrado se refere ao número de bolhas percebidas pelo sensor divididos
pelo tempo levado para amostrar 6 valores de velocidade dentro dos limites do critério de
rejeição de Chauvenet.
Figura 71 - Distribuição de frequência de bolhas
Como podemos observar na figura 71, o histograma de distribuição de frequência
de bolhas se concentra nos valores mais baixos. Alguns valores elevados surgem em
função da densa esteira de bolhas que surge após a passagem de uma bolha de Taylor. O
contador de bolhas detecta essas pequenas bolhas e as inclui no contador, de modo a gerar
um alto valor de frequência. A esteira de bolhas pode ser vista na figura 72.
Figura 72 - Esteira de bolhas formada após a passagem de uma bolha de Taylor
79
6 – Considerações Finais e trabalhos
futuros
No capítulo 1 deste trabalho, vimos a importância da quantificação das variáveis
de interesse em um escoamento multifásico e como o conhecimento destas pode otimizar
um processo industrial, um projeto. Vimos ainda o princípio básico de funcionamento do
sensor eletro-resistivo e como ele pode ajudar na medição de escoamentos bifásicos cujo
acesso ótico seja precário.
No capítulo 2 apresentamos as ferramentas necessárias para a construção do
medidor eletro-resistivo e no capítulo 3 vimos os parâmetros de projeto e algoritmos para
processamento e rejeição estatística e sistemática de resultados discrepantes.
No capítulo 4 vimos alguns periféricos do DSP TMS320F28335, e apresentamos
como cada um foi programado. Vimos ainda como a bancada experimental foi organizada
e como foram feitos os experimentos.
No capítulo 5 vimos que os resultados obtidos com o sinal de defasagem
controlada vindo do software Matlab via conversor D/A foram excelentes. As respectivas
modas dos sinais com três defasagens diferentes ficaram iguais aos valores de referência.
Vimos ainda o funcionamento do sistema medindo a velocidade de subida das bolhas e
que a geometria dos sensores influencia diretamente na determinação dos resultados: com
uma sonda altamente intrusiva, os valores de velocidade medidos estiveram muito abaixo
do resultado de referência obtido pelo Shadow Sizer, enquanto que, utilizando-se uma
sonda menos intrusiva, a moda estatística de velocidade do sensor eletro-resistivo foi
idêntica à obtida pelo Shadow Sizer. Neste capítulo, vimos ainda que a presença de uma
esteira de bolhas pode confundir o contador de bolhas programado no DSP.
Para trabalhos futuros, precisamos melhorar os seguintes aspectos:
A sonda precisa ser menos intrusiva. Para tanto poderemos construir uma sonda
com agulhas de prata, alumínio ou algum outro material de alta condutividade. O
isolamento deve ser feito com uma fina camada de verniz isolante, de modo que
não altere tanto a geometria fina da agulha (como assim fazia a tinta isolante).
O retorno do circuito por uma haste metálica (intrusiva ao escoamento) precisa
ser substituído por um retorno em um tubo de aço inoxidável: nesta nova
80
geometria, as agulhas ficariam centralizadas na seção do tubo externo de aço inox
por um pequeno tubo capilar, também de aço inox, por onde passariam os fios das
agulhas. O trecho do tubo de inox contaria com dois flanges nas suas extremidades
para ligação com o circuito hidráulico.
Com as duas modificações acima, poderemos utilizar o código referente ao
critério de rejeição de Lewis e Davidson presentes no Anexo 3 uma vez que os
sinais serão menos deformados pela intrusão do sensor.
Disponibilizar ao usuário as informações de tamanho de bolhas: para tanto,
devemos utilizar um display de caractere com mais de 2 linhas e atualizar o
programa de aquisição serial para indicar os valores médios de tamanho e dispor
o histograma, assim como é feito com os valores de velocidade.
81
7 –Referências Bibliográficas
[1] Nassos, P. G.; “Development of a electrical Resistivity Probe for Void Fraction
Measurements in Air/Water Flow”. ANL-6738, 1963.
[2] <http://www.mspc.eng.br/tecdiv/med200.shtml> Acesso em 3/07/2015
[3] Lewis, D. A., Davidson, J. F.; “Bubble Sizes Produced by Shear and Turbulence in a
Bubble Column”. Chemical Engineering Science, v. 38, pp 161-168 e pp. 181-187,
1983.
[4] Rezende, S.S., Silva M.O., Emerenciano J.R., Silva Neto J.L.; “Desenvolvimento de
um Sistema de Medição de Fase Utilizando Sensores Eletro-Resistivos”, COBEM,
2007.
[5] Barbosa Junior, J. R.; “O Método dos Sensores Eletro-resistivos aplicado a Pluma de
Bolhas”. Tese de Mestrado, COPPE/UFRJ/Engenharia Mecânica, Brasil, 1997.
[6] Emerenciano, J.R; “Sistema a Sensor Eletro-Resistivo para Estudos de Escoamentos
Bifásicos”. Projeto de Graduação. Engenharia Elétrica – UFRJ, Brasil, 2012.
[7] Texas Instruments, “TMS320F28335/F28334/F28332/F28235/F28234/F28232
Digital Signal Controllers (Rev. M)”, 2012. Disponível em:
< http://www.ti.com/lit/ds/symlink/tms320f28335.pdf> Acesso em 1/07/2015
[8] Texas Instruments, “Hardware Design Guidelines for TMS320F28xx and
TMS320F28xxx DSCs”, 2015. Disponível em:
< http://www.ti.com/lit/an/spraas1c/spraas1c.pdf> Acesso em 8/07/2015
[9] Siqueira, B. A., Barbosa, L. F., Silva, D. D. “Desenvolvimento de um Sistema de
Medição de Fase Utilizando Sensores Eletro-Resistivos”, COBENGE, 2012.
[10] Vieira, L. P.; “Guia de utilização do controlador digital de sinal TMS320F28335”.
Projeto de Graduação. Engenharia Elétrica – UFJF, Brasil, 2013.
[11] Araujo, G. J.; “Sistema de Aquisição de Dados para Estudos de Transiente de
pressão e Detecção de Vazamentos em Oleodutos”. Tese de Mestrado,
PPGCEP/UFRN/Engenharia de Petróleo, Brasil, 2012.
[12] Silva, M. O., Barros, F. P., Silva, M. V., Lage , P. L.; “Análise de Técnica de
Sensores Duplos de Condutividade Para a Obtenção da Velocidade e do Tamanho de
Bolhas Usando Filmagem de Alta Velocidade”. ENEMP, 2007.
82
[13] Texas Instruments, “TMS320x2834x Delfino Serial Communications
Interface (SCI) Reference Guide”, 2009. Disponível em:
< http://www.ti.com/lit/ug/sprug75a/sprug75a.pdf> Acesso em 10/07/2015
[14] Texas Instruments, “Serial Flash Programming of C2000™ Microcontrollers”,
2015. Disponível em:
<http://www.ti.com/lit/an/sprabv4a/sprabv4a.pdf> Acesso em 3/07/2015
[15] Texas Instruments, “Running an Application from Internal Flash Memory on the
TMS320F28xxx DSP”, 2013. Disponível em:
<http://www.ti.com/lit/an/spra958l/spra958l.pdf> Acesso em 3/07/2015
[16] Texas Instruments, “Programming TMS320x28xx and 28xxx Peripherals in
C/C++”, 2013. Disponível em:
<http://www.ti.com/lit/an/spraa85d/spraa85d.pdf> Acesso em 3/07/2015
[17] National Instruments, “Conceitos Gerais de Comunicação Serial”, 2013.
Disponível em:
< http://digital.ni.com/public.nsf/allkb/32679C566F4B9700862576A20051FE8F >
Acesso em 3/07/2015
[18] <http://www.maxwell.vrac.puc-rio.br/10669/10669_2.PDF> Acesso em 3/07/2015
83
ANEXO 1 – Código utilizado no DSP
As seções abaixo foram separadas por questão de organização, porém podem ser tomadas
de forma sequencial.
A1.1 – Inicialização de Variáveis e funções
#include "DSP28x_Project.h"
#include "DSP2833x_Device.h"
#include "DSP2833x_Examples.h"
char *msg;
Uint16 aux10=0;
void scia_echoback_init(void);
void scia_fifo_init(void);
void scia_xmit(int a);
void scia_msg(char *msg);
#include <string.h>
#include <stdlib.h>
#include <math.h>
float distson = 3.0;
Uint16 aux11 =0;
Uint16 aux9=0;
Uint16 aux12=0;
Uint16 countt=0;
Uint16 contador_geral=0;
float T0=0.00010;
float wc = 0.628;
float ttf;
Uint16 count_freq=0;
float fVoltage1=0;
float escala = 10;
Uint16 auxc=1;
float fVoltage2;
float ytk[3] = 0,0,0;
float utk1[3] = 0,0,0;
84
float ytk2[3] = 0,0,0;
float utk2[3] = 0,0,0;
float der1;
float der2;
float der11;
float der22;
float Dx = 0.0030;
float time2;
float time_bolha;
float freq;
float velocidade=0;
float tamanho;
float corda;
float Velx;
float medi=0;
float DP;
float vari=0;
float tsup;
float tinf;
Uint16 couta=1;
Uint16 aux6=0;
Uint16 count4=0;
Uint16 par_a = 1;
Uint16 par_b = 0;
extern Uint16 RamfuncsLoadStart;
extern Uint16 RamfuncsLoadEnd;
extern Uint16 RamfuncsRunStart;
Uint16 Frequencia=0;
Uint16 Velocidade=0;
Uint16 result[3] = 0,0,0;
Uint16 result2[3] = 0,0,0;
Uint16 Contador=0;
Uint16 dif1;
Uint16 dif2;
Uint16 Voltage1;
85
Uint16 Voltage2;
Uint16 aux1=0;
Uint16 aux2=0;
Uint16 aux4=0;
Uint16 count1 = 0;
Uint16 count2 = 0;
Uint16 count3 = 0;
Uint16 var22 = 0;
Uint16 tam=0;
Uint16 Ok = 0;
Uint16 Up = 1;
Uint16 Down = 0;
Uint16 Return = 0;
Uint16 var=0;
Uint16 tam2=0;
Uint16 i=0;
Uint16 j=0;
Uint16 var2=0;
Uint16 tamanh(char strd[]);
Uint16 jjj;
Uint16 ConversionCount=0;
Uint16 aux5=0;
Uint16 N=0;
int bite[]= 0,0,0,0,0,0,0,0;
int delay_value=10;
void disp_vel(float veloc, Uint16 Par);
void disp_freq(float corda, Uint16 Par);
void dela(float del);
void cursor_init_erase(void);
void cursor_init(void);
void cursor_init_l2(void);
void cursor_desloc(Uint16 desl);
void cursor_liga(void);
void cursor_desliga(void);
void stri(char entrada[]);
86
interrupt void adc_isr(void);
char *fti(float num, Uint16 parametro);
char rt2[6]=" ";
char rt4[6]=" ";
char rt6[4]=" ";
char *univel = "m/s";
char *unicor = "Hz";
char *rt;
char *rt3;
char car;
char entrad[16]="Vel.:";
char entrad2[16]="Freq.:";
float C;
Uint16 N2=0;
A1.2 – Função Main
A1.2.1 – Inicialização de periféricos e configurações gerais
main()
InitSysCtrl();
InitSciaGpio();
DINT;
#if (CPU_FRQ_150MHZ) // Default - 150 MHz SYSCLKOUT
#define ADC_MODCLK 0x3 // HSPCLK = SYSCLKOUT/2*ADC_MODCLK2 =
150/(2*3) = 25.0 MHz
#endif
#if (CPU_FRQ_100MHZ)
#define ADC_MODCLK 0x2 // HSPCLK = SYSCLKOUT/2*ADC_MODCLK2 =
100/(2*2) = 25.0 MHz
#endif
EDIS;
EALLOW;
SysCtrlRegs.HISPCP.all = ADC_MODCLK;
EDIS;
87
DINT;
InitPieCtrl();
IER = 0x0000;
IFR = 0x0000;
InitPieVectTable();
MemCopy(&RamfuncsLoadStart, &RamfuncsLoadEnd, &RamfuncsRunStart);
InitFlash();
EALLOW;
PieVectTable.ADCINT = &adc_isr;
EDIS;
EALLOW;
GpioCtrlRegs.GPAMUX1.all = 0;
//GpioCtrlRegs.GPAMUX2.all = 0;
GpioCtrlRegs.GPAMUX1.bit.GPIO2 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO16 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO17 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO18 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO19 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO20 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO21 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO22 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO23 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO24 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO25 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO26 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO27 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO30 = 0;
GpioCtrlRegs.GPAMUX2.bit.GPIO31 = 0;
GpioCtrlRegs.GPADIR.bit.GPIO4= 1;
GpioCtrlRegs.GPADIR.bit.GPIO2= 1;
GpioCtrlRegs.GPADIR.bit.GPIO8= 1;
GpioCtrlRegs.GPADIR.bit.GPIO16 = 1;
GpioCtrlRegs.GPADIR.bit.GPIO17 = 1;
GpioCtrlRegs.GPADIR.bit.GPIO18 = 1;
GpioCtrlRegs.GPADIR.bit.GPIO19 = 1;
88
GpioCtrlRegs.GPADIR.bit.GPIO20 = 1;
GpioCtrlRegs.GPADIR.bit.GPIO21 = 1;
GpioCtrlRegs.GPADIR.bit.GPIO22 = 1;
GpioCtrlRegs.GPADIR.bit.GPIO23 = 1;
GpioCtrlRegs.GPADIR.bit.GPIO24 = 1;
GpioCtrlRegs.GPADIR.bit.GPIO25 = 0;
GpioCtrlRegs.GPADIR.bit.GPIO26 = 1;
GpioCtrlRegs.GPADIR.bit.GPIO27 = 0;
GpioCtrlRegs.GPADIR.bit.GPIO30 = 0;
GpioCtrlRegs.GPADIR.bit.GPIO31 = 0;
EDIS;
GpioDataRegs.GPASET.all = 0X040F0000;
dela(delay_value);
GpioDataRegs.GPACLEAR.bit.GPIO26 = 1;
cursor_init_erase();
GpioDataRegs.GPACLEAR.all = 0x01C70000;
GpioDataRegs.GPASET.all = 0x04380000;
dela(delay_value);
GpioDataRegs.GPACLEAR.bit.GPIO26 = 1;
stri("Medidor de Bolha");
cursor_init_l2();
stri("Eletro-Resistivo");
dela(2000);
jjj=0;
EALLOW;
scia_fifo_init(); // Initialize the SCI FIFO
scia_echoback_init(); // Initalize SCI for echoback
A1.2.2 – Menu de interação com usuário
while(1)
menu1:
if(jjj==0)
cursor_init_erase();
stri("( )Medicao");
89
cursor_init_l2();
stri("( )Configuracoes");
cursor_init();
cursor_desloc(1);
jjj=1;
if((GpioDataRegs.GPADAT.bit.GPIO27==0)&(Up==0))
Up = 1;
Down = 0;
cursor_init();
cursor_desloc(1);
if((GpioDataRegs.GPADAT.bit.GPIO31==0)&(Down==0))
Up = 0;
Down = 1;
cursor_init_l2();
cursor_desloc(1);
if((GpioDataRegs.GPADAT.bit.GPIO25==0)&(Up==1))
break;
if((GpioDataRegs.GPADAT.bit.GPIO25==0)&(Down==1))
menu2:
cursor_init_erase();
stri("( )Unidades");
cursor_init_l2();
stri("( )Dist. Sondas");
cursor_init();
cursor_desloc(1);
Up=1;
Down=0;
while(1)
if((GpioDataRegs.GPADAT.bit.GPIO27==0)&(Up==0))
Up = 1;
Down = 0;
90
cursor_init();
cursor_desloc(1);
if((GpioDataRegs.GPADAT.bit.GPIO31==0)&(Down==0))
Up = 0;
Down = 1;
cursor_init_l2();
cursor_desloc(1);
if(GpioDataRegs.GPADAT.bit.GPIO30==0)
jjj=0;
goto menu1;
if(GpioDataRegs.GPADAT.bit.GPIO25==0&Up==1)
menu3:
cursor_init_erase();
stri("( )Velocidade");
cursor_init_l2();
stri("( )Frequencia");
cursor_init();
cursor_desloc(1);
Up=1;
Down=0;
while(1)
if((GpioDataRegs.GPADAT.bit.GPIO27==0)&(Up==0))
Up = 1;
Down = 0;
cursor_init();
cursor_desloc(1);
if((GpioDataRegs.GPADAT.bit.GPIO31==0)&(Down==0))
Up = 0;
Down = 1;
cursor_init_l2();
cursor_desloc(1);
91
if(GpioDataRegs.GPADAT.bit.GPIO30==0)
jjj=0;
goto menu2;
if(GpioDataRegs.GPADAT.bit.GPIO25==0&Up==1)
cursor_init_erase();
stri("( )m/s");
cursor_init_l2();
stri("( )mm/s");
cursor_init();
cursor_desloc(1);
Up=1;
Down=0;
while(1)
if((GpioDataRegs.GPADAT.bit.GPIO27==0)&(Up==0))
Up = 1;
Down = 0;
cursor_init();
cursor_desloc(1);
if((GpioDataRegs.GPADAT.bit.GPIO31==0)&(Down==0))
Up = 0;
Down = 1;
cursor_init_l2();
cursor_desloc(1);
if(GpioDataRegs.GPADAT.bit.GPIO30==0)
jjj=0;
goto menu3;
if(GpioDataRegs.GPADAT.bit.GPIO25==0&Up==1)
univel = "m/s";
Velocidade = 0;
goto menu3;
92
if(GpioDataRegs.GPADAT.bit.GPIO25==0&Down==1)
univel = "mm/s";
Velocidade = 1000;
goto menu3;
if(GpioDataRegs.GPADAT.bit.GPIO25==0&Down==1)
cursor_init_erase();
stri("( )Hz");
cursor_init_l2();
stri("( )Rpm");
cursor_init();
cursor_desloc(1);
Up=1;
Down=0;
while(1)
if((GpioDataRegs.GPADAT.bit.GPIO27==0)&(Up==0))
Up = 1;
Down = 0;
cursor_init();
cursor_desloc(1);
if((GpioDataRegs.GPADAT.bit.GPIO31==0)&(Down==0))
Up = 0;
Down = 1;
cursor_init_l2();
cursor_desloc(1);
if(GpioDataRegs.GPADAT.bit.GPIO30==0)
jjj=0;
goto menu3;
if(GpioDataRegs.GPADAT.bit.GPIO25==0&Up==1)
93
unicor = "Hz";
Frequencia = 0;
goto menu3;
if(GpioDataRegs.GPADAT.bit.GPIO25==0&Down==1)
unicor = "Rpm";
Frequencia = 60;
goto menu3;
if(GpioDataRegs.GPADAT.bit.GPIO25==0&Down==1)
cursor_desliga();
cursor_init_erase();
stri(" Dist. Sondas");
setcont:
cursor_init_l2();
stri("- ");
strcpy(rt6,fti(distson,1));
stri(rt6);
stri("mm");
stri(" +");
cursor_init();
cursor_desloc(1);
Up=1;
Down=0;
while(1)
if((GpioDataRegs.GPADAT.bit.GPIO27==0)&(distson<31))
distson = distson + 0.1;
Dx = distson/1000;
goto setcont;
if((GpioDataRegs.GPADAT.bit.GPIO31==0)&(distson>(0)))
94
distson = distson - 0.1;
Dx = distson/1000;
goto setcont;
if(GpioDataRegs.GPADAT.bit.GPIO30==0|GpioDataRegs.GPADAT.bit.GPIO25==0)
jjj=0;
cursor_liga();
goto menu2;
delay_value=2;
cursor_desliga();
cursor_init_erase();
stri(entrad);
stri(univel);
cursor_init_l2();
stri(entrad2);
stri(unicor);
delay_value=2;
cursor_desliga();
cursor_init_erase();
stri(entrad);
stri(univel);
cursor_init_l2();
stri(entrad2);
stri(unicor);
InitAdc();
PieCtrlRegs.PIEIER1.bit.INTx6 = 1;
IER |= M_INT1;
EINT;
ERTM;
95
AdcRegs.ADCMAXCONV.all = 0x0001;
AdcRegs.ADCCHSELSEQ1.bit.CONV00 = 0x3;
AdcRegs.ADCCHSELSEQ1.bit.CONV01 = 0x2;
AdcRegs.ADCTRL2.bit.EPWM_SOCA_SEQ1 = 1;
AdcRegs.ADCTRL2.bit.INT_ENA_SEQ1 = 1;
EPwm1Regs.ETSEL.bit.SOCAEN = 1;
EPwm1Regs.ETSEL.bit.SOCASEL = 4;
EPwm1Regs.ETPS.bit.SOCAPRD = 1;
EPwm1Regs.CMPA.half.CMPA = 0x0080;
EPwm1Regs.TBPRD = T0*150000000/2;
EPwm1Regs.TBCTL.bit.CTRMODE = 0;
A1.2.3 – Região de alternância com interrupção
while(1)
if((aux5==0|aux5==1)&(aux9==0)&(fVoltage1!=0)&(aux10==0)&(aux12==0))
cursor_init_erase();
stri(" Obtendo ");
cursor_init_l2();
stri(" Parametros ");
aux10=1;
aux12=1;
if((aux5==0)&(fVoltage1==0)&(aux11==0))
cursor_init_erase();
stri(" Sem Sinal ");
cursor_init_l2();
stri(" Na Entrada ");
aux11=1;
scia_msg("pa");
aux12=0;
countt = 0;
if(auxc==0)
if((aux5==2)&(aux9==0))
96
cursor_init_erase();
stri(entrad);
cursor_init_l2();
stri(entrad2);
aux9=1;
if(par_a==1)
par_a=0;
par_b=1;
disp_vel(medi, Velocidade);
cursor_desloc(1);
stri(univel);
disp_freq(freq, Frequencia);
cursor_desloc(1);
stri(unicor);
scia_msg("a");
ttf=0;
auxc=1;
count2=0;
else
par_a=1;
disp_vel(medi, Velocidade);
cursor_desloc(1);
stri(univel);
disp_freq(freq, Frequencia);
cursor_desloc(1);
stri(unicor);
scia_msg("b");
ttf=0;
auxc=1;
count2=0;
97
A1.3 – Função de Interrupção de ADC
interrupt void adc_isr(void)
GpioDataRegs.GPASET.bit.GPIO2= 1;
Voltage1 = AdcRegs.ADCRESULT0 >>4;
Voltage2 = AdcRegs.ADCRESULT1 >>4;
fVoltage1 = ((float)(Voltage1))*3.169/4095;
fVoltage2 = ((float)(Voltage2))*3.169/4095;
if((contador_geral*T0)<6)
contador_geral++;
else
if((aux4==0)&&(ConversionCount<2))
if(ConversionCount==0) utk1[0]= fVoltage1;
if(ConversionCount==1) utk1[1]= fVoltage1;
if(ConversionCount==0) utk2[0]= fVoltage2;
if(ConversionCount==1) utk2[1]= fVoltage2;
else
if ((aux4==0)&&(ConversionCount==2))
utk1[2]= fVoltage1;
utk2[2]= fVoltage2;
aux4=1;
else
utk1[0]=utk1[1];
utk1[1]=utk1[2];
utk1[2]=fVoltage1;
utk2[0]=utk2[1];
utk2[1]=utk2[2];
utk2[2]= fVoltage2;
ytk[2] = (2*utk1[2] - 2*utk1[1]+((ytk[1])*(2-T0*wc)))/(2 + T0*wc);
98
der1 = (ytk[2]-ytk[1])/(T0*800);
der2 = (ytk[2]-2*ytk[1]+ytk[0])*(0.0000004)/T0;
//result[2]=((der1>0.1)||result[1])&&(1-((der1>-
0.12)&&(der1<0)&&(der2>0)&&(ytk[2]<0.2)));
ytk2[2] = (2*utk2[2] - 2*utk2[1]+((ytk2[1])*(2-T0*wc)))/(2 + T0*wc);
der22=(ytk2[2]-2*ytk2[1]+ytk2[0])*(0.00000015)/T0;
der11 = (ytk2[2]-ytk2[1])/(T0*800);
//result2[2]=((der11>0.1)||result2[1])&&(1-((der11>-
0.12)&&(der11<0)&&(der22>0)&&(ytk2[2]<0.2)));
if(ytk[2]>0.35)
result[2] = 1;
GpioDataRegs.GPASET.bit.GPIO4= 1;
else
result[2] = 0;
GpioDataRegs.GPACLEAR.bit.GPIO4= 1;
if(ytk2[2]>0.35)
result2[2] = 1;
GpioDataRegs.GPASET.bit.GPIO8= 1;
else
result2[2] = 0;
GpioDataRegs.GPACLEAR.bit.GPIO8= 1;
dif1 = result[2]-result[1];
dif2 = result2[2]-result2[1];
if((dif1==1)||(aux1==1))
if(aux1==0)
aux1=1;
Contador = Contador + 1;
count1 = count1 + 1;
if((dif2==1)&&(aux2==0))
time2 = (Contador-1)*T0;
velocidade = Dx/(time2);
99
time2=0;
count2 = count2+1;
if(velocidade<escala)
Velx = velocidade;
aux6=1;
if(aux5==0)
ttf = ttf+Velx;
N++;
N2=0;
if(aux5==1)
ttf = ttf+Velx;
vari = (Velx-medi)*(Velx-medi) + vari;
N++;
N2=0;
if((aux5==2)&(Velx<tsup)&(Velx>tinf))
count_freq++;
N2=0;
ttf = ttf+Velx;
vari = (Velx-medi)*(Velx-medi)+vari;
N++;
//disp_vel(velocidade);
aux2=1;
Contador=0;
if(dif1==-1)
if(velocidade != 0)
time_bolha = (count1-1)*T0;
tamanho = velocidade*time_bolha;
//disp_corda(tamanho*1000);
aux2=0;
velocidade = 0;
100
count1=0;
aux2=0;
Contador=0;
velocidade=0;
aux1=0;
ytk[0]=ytk[1];
ytk[1]=ytk[2];
ytk2[0]=ytk2[1];
ytk2[1]=ytk2[2];
result[0]=result[1];
result[1]=result[2];
result2[0]=result2[1];
result2[1]=result2[2];
if(couta*T0>4)
if(N==0)
aux5=0;
Velx=0;
freq=0;
medi=0;
ttf=0;
vari=0;
aux6=0;
aux9=0;
aux10=0;
aux11=0;
count2=0;
tinf = 0;
tsup = 0;
DP=0;
count_freq=0;
count4=0;
101
if(N2==1)
N=0;
N2=1;
couta=0;
if(N>6)
if(aux5==0)
aux5=1;
medi=ttf/N;
N=0;
count2=0;
count_freq=0;
count4=0;
if(aux5==1&N!=0)
medi=ttf/N;
DP = sqrt(vari/(N-1));
C = 1.73;
tsup = C*DP+medi;
tinf = medi-C*DP;
aux5=2;
N=0;
count2=0;
count_freq=0;
count4=0;
if(aux5==2&N!=0)
medi = ttf/N;
DP = sqrt(vari/(N-1));
C = 1.73;
tsup = C*DP+medi;
tinf = medi-C*DP;
N=0;
102
auxc=0;
// if ((count_freq/((count4-1)*T0)<3))
freq = count_freq/((count4-1)*T0);//
count_freq=0;
count4=0;
couta=0;
ttf=0;
var=0;
vari=0;
if(aux6==1)
couta++;
count4++;
if(ConversionCount == 2)
ConversionCount = 0;
else ConversionCount++;
GpioDataRegs.GPACLEAR.bit.GPIO2= 1;
AdcRegs.ADCTRL2.bit.RST_SEQ1 = 1;
AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;
PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
return;
A1.4 – Funções Gerais Utilizadas no código
void disp_vel(float veloc, Uint16 Par)
rt= fti(veloc,Par);
cursor_init();
cursor_desloc(5);
strcpy(rt2,rt);
stri(rt2);
103
scia_msg(rt2);
void disp_freq(float corda,Uint16 Par)
rt3= fti(corda, Par);
cursor_init_l2();
cursor_desloc(6);
strcpy(rt4,rt3);
stri(rt4);
scia_msg(rt4);
void stri(char entrada[]) //função para mandar uma string de entrada ao display
var=0;
tam =tamanh(entrada); //AQUI DEFINO O TAMANHO DA MINHA STRING DE
TEXTO PADRÃO
while (var<(tam))
car = entrada[var];
bite[0] = (car&(1));
bite[1] = ((car)&(2))>>1;
bite[2] = ((car)&(4))>>2;
bite[3] = ((car)&(8))>>3;
bite[4] = ((car)&(16))>>4;
bite[5] = ((car)&(32))>>5;
bite[6] =((car)&(64))>>6;
bite[7] = ((car)&(128))>>7;
GpioDataRegs.GPADAT.bit.GPIO24 = 1;
if(bite[0]==1) GpioDataRegs.GPASET.bit.GPIO16 = 1;
else GpioDataRegs.GPACLEAR.bit.GPIO16 = 1;
if(bite[1]==1) GpioDataRegs.GPASET.bit.GPIO17 = 1;
else GpioDataRegs.GPACLEAR.bit.GPIO17 = 1;
if(bite[2]==1) GpioDataRegs.GPASET.bit.GPIO18 = 1;
else GpioDataRegs.GPACLEAR.bit.GPIO18 = 1;
if(bite[3]==1) GpioDataRegs.GPASET.bit.GPIO19 = 1;
else GpioDataRegs.GPACLEAR.bit.GPIO19 = 1;
if(bite[4]==1) GpioDataRegs.GPASET.bit.GPIO20 = 1;
else GpioDataRegs.GPACLEAR.bit.GPIO20 = 1;
104
if(bite[5]==1) GpioDataRegs.GPASET.bit.GPIO21 = 1;
else GpioDataRegs.GPACLEAR.bit.GPIO21 = 1;
if(bite[6]==1) GpioDataRegs.GPASET.bit.GPIO22 = 1;
else GpioDataRegs.GPACLEAR.bit.GPIO22 = 1;
if(bite[7]==1) GpioDataRegs.GPASET.bit.GPIO23 = 1;
else GpioDataRegs.GPACLEAR.bit.GPIO23 = 1;
GpioDataRegs.GPASET.bit.GPIO26 = 1;
dela(delay_value);
GpioDataRegs.GPACLEAR.bit.GPIO26 = 1;
var++;
var22 = 0;
void dela(float del) //função que executa o delay
Uint32 result;
Uint32 jj=0;
result=del*90000000/13157;
while(jj<result)
jj++;
jj=0;
Uint16 tamanh(char strd[]) //função que me retorna o tamanho da string
int aaa = 0;
while(strd[aaa]!='\0')
aaa++;
return aaa;
char *fti(float num, Uint16 parametro) //função que converte o float de entrada em
string
Uint16 n1=0;
Uint16 n2=0;
Uint16 n3=0;
Uint16 n4=0;
Uint16 n5=0;
105
char *s;
s = malloc( 6 * sizeof (char));
if(parametro==0)
char c1,c2,c3,c4;
n1= num/10;
n2= (num-(n1*10))/1;
n3 = ((num*10-n1*100-n2*10))/1;
n4=(num*100-n1*1000-n2*100-n3*10)/1;
c1 = n1 + 48;
c2 = n2 + 48;
c3 = n3 + 48;
c4 = n4 + 48;
s[0] = c1;
s[1] = c2;
s[2] = '.';
s[3] = c3;
s[4] = c4;
s[5] = '\0';
else if(parametro==1)
char c1,c2,c3;
n1= num/10;
n2= (num-(n1*10))/1;
n3 = ((num*10-n1*100-n2*10))/1;
c1 = n1 + 48;
c2 = n2 + 48;
c3 = n3 + 48;
if(n1!=0)
s[0] = c1;
else
s[0] = ' ';
if(n2!=0)
s[1] = c2;
106
else
s[1] = ' ';
s[2] = '.';
s[3] = c3;
s[4] = '\0';
else if(parametro==60)
num = num*parametro;
char c1,c2,c3,c4,c5;
n1= num/10000;
n2= (num-(n1*10000))/1000;
n3 = ((num-n1*10000-n2*1000))/100;
n4=(num-n1*10000-n2*1000-n3*100)/10;
n5=(num-n1*10000-n2*1000-n3*100-n4*10);
c1 = n1 + 48;
c2 = n2 + 48;
c3 = n3 + 48;
c4 = n4 + 48;
c5 = n5 + 48;
if(n1==0)
s[0] = ' ';
else
s[0] = n1;
if((n2==0)&(n1==0))
s[1] = ' ';
else
s[1] = c2;
if((n3==0)&(n1==0)&(n2==0))
s[2] = ' ';
107
else
s[2] = c3;
if((n3==0)&(n1==0)&(n2==0)&(n4==0))
s[3] = ' ';
else
s[3] = c4;
s[4] = c4;
s[5] = '\0';
else
num = num*parametro;
char c1,c2,c3,c4,c5;
n1= num/10000;
n2= (num-(n1*10000))/1000;
n3 = ((num-n1*10000-n2*1000))/100;
n4=(num-n1*10000-n2*1000-n3*100)/10;
n5=(num-n1*10000-n2*1000-n3*100-n4*10);
c1 = n1 + 48;
c2 = n2 + 48;
c3 = n3 + 48;
c4 = n4 + 48;
c5 = n5 + 48;
if(n1==0)
s[0] = ' ';
else
s[0] = n1;
if((n2==0)&(n1==0))
s[1] = ' ';
108
else
s[1] = c2;
if((n3==0)&(n1==0)&(n2==0))
s[2] = ' ';
else
s[2] = c3;
if((n3==0)&(n1==0)&(n2==0)&(n4==0))
s[3] = ' ';
else
s[3] = c4;
s[4] = c4;
s[5] = '\0';
return(s);
void cursor_init_erase(void)
GpioDataRegs.GPACLEAR.all = 0x01FE0000;
GpioDataRegs.GPASET.all = 0x04010000;
dela(delay_value);
GpioDataRegs.GPACLEAR.bit.GPIO26 = 1;
void cursor_init(void)
GpioDataRegs.GPACLEAR.all = 0x01FD0000;
GpioDataRegs.GPASET.all = 0x04020000;
dela(delay_value);
GpioDataRegs.GPACLEAR.bit.GPIO26 = 1;
void cursor_init_l2(void)
GpioDataRegs.GPACLEAR.all = 0x013F0000;
109
GpioDataRegs.GPASET.all = 0x04C00000;
dela(delay_value);
GpioDataRegs.GPACLEAR.bit.GPIO26 = 1;
void cursor_desloc(Uint16 desl)
GpioDataRegs.GPASET.all = 0x00140000;
GpioDataRegs.GPACLEAR.all = 0x00EB0000;
j=0;
while(j<desl)
GpioDataRegs.GPASET.bit.GPIO26 = 1;
dela(delay_value);
GpioDataRegs.GPACLEAR.bit.GPIO26 = 1;
j++;
void cursor_desliga(void)
GpioDataRegs.GPACLEAR.all = 0x01F30000;
GpioDataRegs.GPASET.all = 0x040C0000;
dela(delay_value);
GpioDataRegs.GPACLEAR.bit.GPIO26 = 1;
void cursor_liga(void)
GpioDataRegs.GPACLEAR.all = 0X01F00000;
GpioDataRegs.GPASET.all = 0X040F0000;
dela(delay_value);
GpioDataRegs.GPACLEAR.bit.GPIO26 = 1;
// Test 1,SCIA DLB, 8-bit word, baud rate 0x000F, default, 1 STOP bit, no parity
void scia_echoback_init()
// Note: Clocks were turned on to the SCIA peripheral
// in the InitSysCtrl() function
SciaRegs.SCICCR.all =0x0007; // 1 stop bit, No loopback
// No parity,8 char bits,
// async mode, idle-line protocol
SciaRegs.SCICTL1.all =0x0003; // enable TX, RX, internal SCICLK,
110
// Disable RX ERR, SLEEP, TXWAKE
SciaRegs.SCICTL2.all =0x0003;
SciaRegs.SCICTL2.bit.TXINTENA =1;
SciaRegs.SCICTL2.bit.RXBKINTENA =1;
#if (CPU_FRQ_150MHZ)
SciaRegs.SCIHBAUD =0x0001; // 9600 baud @LSPCLK = 37.5MHz.
SciaRegs.SCILBAUD =0x00E7;
#endif
#if (CPU_FRQ_100MHZ)
SciaRegs.SCIHBAUD =0x0001; // 9600 baud @LSPCLK = 20MHz.
SciaRegs.SCILBAUD =0x0044;
#endif
SciaRegs.SCICTL1.all =0x0023; // Relinquish SCI from Reset
// Transmit a character from the SCI
void scia_xmit(int a)
while (SciaRegs.SCIFFTX.bit.TXFFST != 0)
SciaRegs.SCITXBUF=a;
void scia_msg(char *msg)
int i;
i = 0;
while(msg[i] != '\0')
scia_xmit(msg[i]);
i++;
// Initalize the SCI FIFO
void scia_fifo_init()
SciaRegs.SCIFFTX.all=0xE040;
SciaRegs.SCIFFRX.all=0x204f;
SciaRegs.SCIFFCT.all=0x0;
111
ANEXO 2 – Código utilizado no CVI
#include <ansi_c.h>
#include <cvirte.h>
#include <userint.h>
#include <rs232.h>
#include <utility.h>
#include <formatio.h>
#include <string.h>
#include "serial_v2.h"
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#define HELP_MSG \
"This program serves as an example to illustrate the use of the \n"\
"Histogram and Mode functions in the Analysis libraries. The mode \n"\
"value is defined as the value that most often occurs in a given set \n"\
"of samples."
#include <cvirte.h> /* needed if linking executable in external compiler; harmless
otherwise */
#include <formatio.h>
#include <analysis.h>
#include <userint.h>
#include "mode.h"
int m_aux1=1;
int m_aux2=0;
double DataArray[2000];
int count00;
float maximo = 0;
static int panelHandle;
int contador2=1;
FILE *OutFile;
int chave2;
int aux6 = 0;
int w;
112
int receive;
int chave;
char nome[520];
char diretorio[520];
char extensao[520];
int exten;
int aux2;
float periodo;
double coint2=0;
float freq;
float temp=1;
int parar;
long int count=1;
int RS232Error;
double std(char entrada[]);
double saida;
int aux1=0;
char te2[6];
double saida2;
int a, b, c, d;
double e;
char te[6];
int panel_handle,
config_handle,
comport,
baudrate,
portindex,
parity,
databits,
stopbits,
inputq, /* Sets input queue length in OpenComConfig */
outputq, /* Sets output queue length in OpenComConfig */
xmode,
ctsmode,
stringsize,
113
bytes_sent,
bytes_read,
RS232Error,
config_flag,
breakstatus,
port_open,
com_status,
send_mode,
send_byte,
send_term_index,
read_term_index,
read_term,
inqlen, /* Stores result from GetInQLen */
outqlen; /* Stores result from GetOutQLen */
short read_cnt;
double timeout;
double teste;
char devicename[30];
char read_data[44];
static int serial;
int main (int argc, char *argv[])
if (InitCVIRTE (0, argv, 0) == 0)
return -1; /* out of memory */
if ((serial = LoadPanel (0, "serial_v2.uir", SERIAL)) < 0)
return -1;
DisplayPanel (serial);
RunUserInterface ();
DiscardPanel (serial);
return 0;
int CVICALLBACK OkCallback (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
switch (event)
case EVENT_COMMIT:
GetCtrlVal (serial, SERIAL_COMPORT, &comport);
114
GetCtrlVal (serial, SERIAL_BAUDRATE, &baudrate);
GetCtrlVal (serial, SERIAL_PARITY, &parity);
GetCtrlVal (serial, SERIAL_DATABITS, &databits);
GetCtrlVal (serial, SERIAL_STOPBITS, &stopbits);
inputq = 64;
outputq = 64;
GetCtrlIndex (serial, SERIAL_COMPORT, &portindex);
aux1=1;
break;
return 0;
int CVICALLBACK QuitCallback (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
switch (event)
case EVENT_COMMIT:
QuitUserInterface (0);
break;
return 0;
int CVICALLBACK tempo (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
switch (event)
static int intervals;
static ssize_t hist[101];
static double axis[101];
double modeValue;
static double max, min;
static ssize_t imax, imin;
static int i;
static char message[64];
case EVENT_TIMER_TICK:
GetCtrlVal (serial, SERIAL_BINARYSWITCH, &chave);
GetCtrlVal (serial, SERIAL_BINARYSWITCH_2, &chave2);
115
GetCtrlVal (serial, SERIAL_TOGGLEBUTTON , ¶r);
if(chave2==0)
SetCtrlVal(serial,SERIAL_LED_2,0);
if((aux1==1)&(chave2==1))
DisableBreakOnLibraryErrors (); //desabilita aparecimento de erros
RS232Error = OpenComConfig (comport, devicename, baudrate, parity, databits,
stopbits, inputq, outputq); //configura porta
EnableBreakOnLibraryErrors ();
switch (RS232Error)
default :
if (RS232Error != 0) //mensagem padrão de erro
MessagePopup ("RS232 Erro", "Fonte de Entrada Serial Não encontrada");
aux1=0;
SetCtrlVal(serial,SERIAL_LED_2,0);
break;
case 0 :
SetCtrlVal(serial,SERIAL_LED_2,1);
bytes_read = ComRd (comport, read_data, 11);
te[0] = read_data[0] ;
te[1] = read_data[1] ;
te[2]= read_data[2] ;
te [3] = read_data[3] ;
te[4] = read_data[4] ;
saida = std(te);
te2[0] = read_data[5] ;
te2[1] = read_data[6] ;
te2[2]= read_data[7] ;
te2[3] = read_data[8] ;
te2[4] = read_data[9];
if((read_data[10]=='a')&&(m_aux1==1))
m_aux1=0;
m_aux2=1;
if((read_data[0]=='p')&(contador2==1))
116
aux1=0;
SetCtrlVal(serial,SERIAL_LED_2,0);
contador2=0;
if((read_data[0]!='p'))
contador2=1;
if((chave==1)&(aux6==1)&(saida>0))
fprintf(OutFile,"%s\t%s \n",te,te2);
if((parar==1)&(saida>0))
if(te[2] == '.')
SetCtrlVal(serial,SERIAL_TEXTMSG_3,"m/s");
else
SetCtrlVal(serial,SERIAL_TEXTMSG_3,"mm/s");
if(te2[2] == '.')
SetCtrlVal(serial,SERIAL_TEXTMSG_4,"Hz");
else
SetCtrlVal(serial,SERIAL_TEXTMSG_4,"Rpm");
saida2 = std(te2);
coint2=coint2+1;
SetCtrlVal(serial,SERIAL_NUME,saida);
SetCtrlVal(serial,SERIAL_NUME2,saida2);
if(saida>0)
// DADOS ESTATÍSTICOS
DataArray[count00] = saida;
count00++;
intervals=35; //RESOLUÇÃO DO HISTOGRAMA
if(count00>10)
MaxMin1D (DataArray,count00, &max, &imax, &min, &imin);
117
Mode (DataArray, count00, min, max, intervals, &modeValue);
Histogram (DataArray, count00, min, max, hist, axis, intervals);
SetCtrlVal (serial, SERIAL_HISTMIN, min);
SetCtrlVal (serial, SERIAL_HISTMAX, max);
SetCtrlVal (serial, SERIAL_MODE, modeValue);
DeleteGraphPlot (serial, SERIAL_GRAPH, -1, VAL_DELAYED_DRAW);
PlotXY (serial, SERIAL_GRAPH, axis, hist, intervals,
VAL_DOUBLE, VAL_SSIZE_T, VAL_VERTICAL_BAR,
VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);
if(count00==1999)
count00=0;
////////////////////////////////////////////
if((read_data[10]=='b')&&(m_aux2==1))
m_aux1=1;
m_aux2=0;
if((read_data[0]=='p')&(contador2==1))
aux1=0;
SetCtrlVal(serial,SERIAL_LED_2,0);
contador2=0;
if((read_data[0]!='p'))
contador2=1;
if((chave==1)&(aux6==1)&(saida>0))
fprintf(OutFile,"%s\t%s \n",te,te2);
if((parar==1)&(saida>0))
if(te[2] == '.')
SetCtrlVal(serial,SERIAL_TEXTMSG_3,"m/s");
else
SetCtrlVal(serial,SERIAL_TEXTMSG_3,"mm/s");
118
if(te2[2] == '.')
SetCtrlVal(serial,SERIAL_TEXTMSG_4,"Hz");
else
SetCtrlVal(serial,SERIAL_TEXTMSG_4,"Rpm");
saida2 = std(te2);
coint2=coint2+1;
SetCtrlVal(serial,SERIAL_NUME,saida);
SetCtrlVal(serial,SERIAL_NUME2,saida2);
if(saida>0)
// DADOS ESTATÍSTICOS
DataArray[count00] = saida;
count00++;
intervals=35; //RESOLUÇÃO DO HISTOGRAMA
// DataArray
if(count00>10)
MaxMin1D (DataArray,count00, &max, &imax, &min, &imin);
Mode (DataArray, count00, min, max, intervals, &modeValue);
Histogram (DataArray, count00, min, max, hist, axis, intervals);
SetCtrlVal (serial, SERIAL_HISTMIN, min);
SetCtrlVal (serial, SERIAL_HISTMAX, max);
SetCtrlVal (serial, SERIAL_MODE, modeValue);
DeleteGraphPlot (serial, SERIAL_GRAPH, -1, VAL_DELAYED_DRAW);
PlotXY (serial, SERIAL_GRAPH, axis, hist, intervals,
VAL_DOUBLE, VAL_SSIZE_T, VAL_VERTICAL_BAR,
VAL_EMPTY_SQUARE, VAL_SOLID, 1, VAL_RED);
if(count00==1999)
count00=0;
119
////////////////////////////////////////////
break;
return 0;
double std(char entrada[])
int a=0, b=0, c=0, d=0,f=0;
double e;
if(entrada[2]=='.')
a= entrada[0]-48;
b = entrada[1]-48;
c= entrada[3]-48;
d = entrada[4]-48;
e = a*10+b + c/10.0 + d/100.0;
else
if(entrada[0]!=' ')
a= entrada[0]-48;
if(entrada[1]!=' ')
b = entrada[1]-48;
if(entrada[3]!=' ')
c= entrada[3]-48;
if(entrada[4]!=' ')
d = entrada[4]-48;
f = entrada[2]-48;
e = a*10000+b*1000 + f*100 + c*10 + d;
return e;
120
int CVICALLBACK OkCallback2 (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
switch (event)
case EVENT_COMMIT:
GetCtrlVal (serial, SERIAL_STRING, diretorio);
GetCtrlVal (serial, SERIAL_STRING_2, nome);
GetCtrlVal (serial, SERIAL_EXTENS, &exten);
if(exten==0)
strcpy(extensao,".txt");
if(exten==1)
strcpy(extensao,".csv");
if(exten==2)
strcpy(extensao,".dat");
strcat(diretorio,"\\");
strcat(diretorio,nome);
strcat(diretorio,extensao);
GetCtrlVal (serial, SERIAL_BINARYSWITCH, &chave);
if((chave==1)&(aux6==0))
OutFile=fopen(diretorio,"w");
SetCtrlVal(serial,SERIAL_LED,1);
aux6=1;
if((chave==0)&(aux6==1))
fclose(OutFile);
SetCtrlVal(serial,SERIAL_LED,0);
aux6=0;
break;
return 0;
121
ANEXO 3 – Função ADC_isr utilizando o
critério de Lewis e Davidson
Nas linhas de código a seguir, seguem as variáveis a serem inicializadas e a função de
interrupção ADC com o critério de Lewis e Davidson adicionado.
#include "DSP28x_Project.h"
#include "DSP2833x_Device.h"
#include "DSP2833x_Examples.h"
char *msg;
void scia_echoback_init(void);
void scia_fifo_init(void);
void scia_xmit(int a);
void scia_msg(char *msg);
#include <string.h>
#include <stdlib.h>
#include <math.h>
float c_velocidade;
Uint16 envia =1;
Uint16 envib = 0;
Uint16 c_aux3=0;
Uint16 m_aux1=0;
Uint16 c_aux4=0;
Uint16 c_aux5=0;
Uint16 c_auf1=0;
Uint16 c_auf2=0;
Uint16 c_count3=0;
Uint16 c_count4=0;
Uint16 c_count1;
Uint16 c_count2;
122
float c_velocidade2;
float c_s1;
float c_s2;
float c_time_bolha2;
float c_time3;
float c_tanx;
float c_tanx2;
Uint16 c_aux7=0;
float distson = 3.5;
Uint16 aux10=0;
Uint16 aux11 =0;
Uint16 aux9=0;
Uint16 aux12=0;
Uint16 countt=0;
float T0=0.00020;
float wc = 0.628;
float ttf;
Uint16 count_freq=0;
float fVoltage1=0;
float escala = 10;
Uint16 auxc=1;
float fVoltage2;
float ytk[3] = 0,0,0;
float utk1[3] = 0,0,0;
float ytk2[3] = 0,0,0;
float utk2[3] = 0,0,0;
float der1;
float der2;
float der11;
123
float der22;
float Dx = 0.0035;
float c_time2;
float time_bolha;
float freq;
float velocidade=0;
float tamanho;
float corda;
float Velx;
float medi=0;
float DP;
float vari=0;
float tsup;
float tinf;
Uint16 couta=1;
Uint16 aux6=0;
Uint16 count4=0;
extern Uint16 RamfuncsLoadStart;
extern Uint16 RamfuncsLoadEnd;
extern Uint16 RamfuncsRunStart;
Uint16 Frequencia=0;
Uint16 Velocidade=0;
Uint16 result[3] = 0,0,0;
Uint16 result2[3] = 0,0,0;
Uint16 Contador=0;
Uint16 dif1;
Uint16 dif2;
Uint16 Voltage1;
Uint16 Voltage2;
124
Uint16 aux1=0;
Uint16 aux2=0;
Uint16 aux4=0;
Uint16 count1 = 0;
Uint16 count2 = 0;
Uint16 count3 = 0;
Uint16 var22 = 0;
Uint16 tam=0;
Uint16 Ok = 0;
Uint16 Up = 1;
Uint16 Down = 0;
Uint16 Return = 0;
Uint16 var=0;
Uint16 tam2=0;
Uint16 i=0;
Uint16 j=0;
Uint16 var2=0;
Uint16 tamanh(char strd[]);
Uint16 jjj;
Uint16 ConversionCount=0;
Uint16 aux5=0;
Uint16 N=0;
int bite[]= 0,0,0,0,0,0,0,0;
int delay_value=20;
void disp_vel(float veloc, Uint16 Par);
void disp_freq(float corda, Uint16 Par);
void dela(float del);
void cursor_init_erase(void);
void cursor_init(void);
125
void cursor_init_l2(void);
void cursor_desloc(Uint16 desl);
void cursor_liga(void);
void cursor_desliga(void);
void stri(char entrada[]);
interrupt void adc_isr(void);
char* fti(float num, Uint16 parametro);
char rt2[6]=" ";
char rt4[6]=" ";
char rt6[4]=" ";
char *univel = "m/s";
char *unicor = "Hz";
char *rt;
char *rt3;
char car;
char entrad[16]="Vel.:";
char entrad2[16]="Freq.:";
float C;
Uint16 N2=0;
interrupt void adc_isr(void)
Voltage1 = AdcRegs.ADCRESULT0 >>4;
Voltage2 = AdcRegs.ADCRESULT1 >>4;
fVoltage1 = ((float)(Voltage1))*3.169/4095;
fVoltage2 = ((float)(Voltage2))*3.169/4095;
if((aux4==0)&&(ConversionCount<2)) //aux4 serve para preencher as condições
iniciais apenas uma vez
if(ConversionCount==0) utk1[0]= fVoltage1;
if(ConversionCount==1) utk1[1]= fVoltage1;
if(ConversionCount==0) utk2[0]= fVoltage2;
if(ConversionCount==1) utk2[1]= fVoltage2;
126
else
if ((aux4==0)&&(ConversionCount==2))
utk1[2]= fVoltage1;
utk2[2]= fVoltage2;
aux4=1; //desabilito aux4
else
utk1[0]=utk1[1];
utk1[1]=utk1[2];
utk1[2]=fVoltage1;
utk2[0]=utk2[1];
utk2[1]=utk2[2];
utk2[2]= fVoltage2;
ytk[2] = (2*utk1[2] - 2*utk1[1]+((ytk[1])*(2-T0*wc)))/(2 + T0*wc);
//der1 = (ytk[2]-ytk[1])/(T0*800);
//der2 = (ytk[2]-2*ytk[1]+ytk[0])*(0.0000004)/T0;
//result[2]=((der1>0.1)||result[1])&&(1-((der1>-
0.12)&&(der1<0)&&(der2>0)&&(ytk[2]<0.2)));
ytk2[2] = (2*utk2[2] - 2*utk2[1]+((ytk2[1])*(2-T0*wc)))/(2 + T0*wc);
//der22=(ytk2[2]-2*ytk2[1]+ytk2[0])*(0.00000015)/T0;
//der11 = (ytk2[2]-ytk2[1])/(T0*800);
//result2[2]=((der11>0.1)||result2[1])&&(1-((der11>-
0.12)&&(der11<0)&&(der22>0)&&(ytk2[2]<0.2)));
if(ytk[2]>0.5)
result[2] = 1;
else
result[2] = 0;
127
if(ytk2[2]>0.5)
result2[2] = 1;
else
result2[2] = 0;
dif1 = result[2]-result[1];
dif2 = result2[2]-result2[1];
if((dif1==1)||(aux1==1)) //aux1 habilita a entrada neste if após o primeiro dif1=1
if(aux1==0) //após entrar no if eu habilito aux1 para que a partir de agora se entre no
if através do aux1
aux1=1;
Contador = Contador + 1; //esse é o meu contador principal habilitado quando entro
no if e zerado quando eu saio
count1 = count1 + 1;//esse é o meu contador principal habilitado quando entro no if
e zerado quando eu saio
if((dif2==1)&&(aux2==0)) //quando a bolha 2 começa pela primeira vez eu entro
aqui (pois aux2=0)
c_time2 = (Contador-1)*T0; //é o tempo de atraso entre frente de bolha1 e 2
c_velocidade = Dx/(c_time2); //a velocidade é a distância entre sondas dividido
pelo tempo
// c_time2=0; //reseto meu tempo, pois já calculei a velocidade
count2 = count2+1; //esse é o meu contador de bolhas
aux2=1 ; //desabilito a entrada nese if, caso apareça mais de uma bolha2
c_aux3=1; //auxiliar que habilita contagem de tamanho da bolha2
c_aux4=1; //auxiliar que habilita entrar em if de final da bolha2
if (c_aux3==1)
c_count4++;
128
//contagem de bolha2
if((dif1==-1)&&(c_aux7==0)) //final da bolha1
c_aux7=1;
m_aux1=1;
if(c_velocidade != 0) //se ao final da bolha1, alguma velocidade tiver sido definida,
ou seja, se tiver tido ocorrencia da bolha2
time_bolha = (count1-1)*T0; //tempo de duração da bolha1 é função do contador
principal
//tamanho = velocidade*time_bolha;
c_tanx=time_bolha; //guardo essa duração de bolha1 nesta variavel
//aux2=0;
//c_velocidade = 0;
c_auf1=1;//auxiliar de final de bolha1
c_s1=(count1-1)*T0;//tempo do fim da bolha1
else //se não tiver tido ocorrência de bolha2, eu zero tudo e espero a próxima
count1=0;
aux2=0;
Contador=0;
c_velocidade=0;
aux1=0;
c_aux3=0;
c_aux4=0;
c_aux5=0;
c_aux7=0;
c_auf1=0;
c_auf2=0;
c_count3=0;
c_count4=0;
c_velocidade2=0;
m_aux1=0;
if ((dif2==-1)&&(c_aux4==1)) //se chega o final da bolha2
129
if(m_aux1==1)
c_time_bolha2=(c_count4-1)*T0; //define duração da bolha2
c_aux4=0;
c_auf2=1; //auxiliar que bolha 2 acabou
c_count4=0; //contador de tamaho de bolha2
c_aux3=0;
c_s2=(count1-1)*T0; //tempo do fim da bolha 2;
if(c_s1>c_s2)
c_velocidade2=Dx/((c_s1-c_s2)); //velocidade2 definida pela diferença entre
parte trazeira da bolha
c_time3=((c_s1-c_s2)); //time3 é o tempo de atraso entre costas das bolhas
if(c_s2>c_s1)
c_velocidade2=Dx/((c_s2-c_s1));
c_time3=((c_s2-c_s1));
if (((c_time3>c_time2*0.85)&&(c_time3<c_time2*1.15)))
velocidade = (c_velocidade+c_velocidade2)/2
tamanho= (c_tanx+c_tanx2)*velocidade/2;
c_tanx2=c_time_bolha2;
aux1=0;
aux2=0;
c_aux3=0;
c_aux4=0;
c_aux5=0;
c_aux7=0;
c_count1=0;
c_count2=0;
c_count3=0;
c_count4=0;
130
c_auf1=0;
c_auf2=0;
count1=0;
Contador=0;
c_velocidade=0;
c_velocidade2=0;
m_aux1=0;
if(velocidade<escala)
count_freq++;
Velx = velocidade; //guardo velocidade numa auxiliar
aux6=1;
if(aux5==0)
ttf = ttf+Velx; //vou somando as velocidades
N++; //vou incrementando numero de bolhas boas
N2=0;
if(aux5==1)
ttf = ttf+Velx;//vou somando as velocidades
vari = (Velx-medi)*(Velx-medi) + vari;
N++;//vou incrementando numero de bolhas boas
N2=0;
if((aux5==2)&(Velx<tsup)&(Velx>tinf))
N2=0;
ttf = ttf+Velx;
vari = (Velx-medi)*(Velx-medi)+vari;
N++;
else
131
aux1=0;
aux2=0;
c_aux3=0;
c_aux4=0;
c_aux5=0;
c_aux7=0;
c_count1=0;
c_count2=0;
c_count3=0;
c_count4=0;
c_auf1=0;
c_auf2=0;
count1=0;
Contador=0;
c_velocidade=0;
c_velocidade2=0;
m_aux1=0;
//aux2=1;
//Contador=0;
ytk[0]=ytk[1];
ytk[1]=ytk[2];
ytk2[0]=ytk2[1];
ytk2[1]=ytk2[2];
result[0]=result[1];
result[1]=result[2];
result2[0]=result2[1];
result2[1]=result2[2];
if(couta*T0>4) //se meu overtime ultrapassa 4s
if(N==0) //se eu no tiver contado nenhuma bolha til em 4s
132
//zero todas as minhas variaveis
aux5=0;
Velx=0;
freq=0;
medi=0;
ttf=0;
vari=0;
aux6=0;
aux9=0;
aux10=0;
aux11=0;
count2=0;
tinf = 0;
tsup = 0;
DP=0;
count_freq=0;
count4=0;
if(N2==1)
N=0;
N2=1;
couta=0; //zero meu contador de overtime
if(N>4)
if(aux5==0)
aux5=1; //jogo a ficha pra aux5
medi=ttf/N;
N=0;
count2=0; //
count_freq=0; //zero meu contador de frequencia
133
count4=0; //
if(aux5==1&N!=0)
medi=ttf/N;
DP = sqrt(vari/(N-1));
C = 1.65;
tsup = C*DP+medi;
tinf = medi-C*DP;
aux5=2;
N=0;
count2=0;
count_freq=0;
count4=0;
if(aux5==2&N!=0)
medi = ttf/N;
DP = sqrt(vari/(N-1));
C = 1.65;
tsup = C*DP+medi;
tinf = medi-C*DP;
N=0;
auxc=0; //a partir daqui eu posso indicar os valores de velocidade e frequencia
freq = count_freq/((count4-1)*T0);
count_freq=0;
count4=0;
couta=0; //contador de overtime zera
ttf=0;
var=0;
vari=0;
if(aux6==1)
134
couta++;//incremento contador de overtime
count4++; //contador de tempo para frequencia
if(ConversionCount == 2)
ConversionCount = 0;
else ConversionCount++;
AdcRegs.ADCTRL2.bit.RST_SEQ1 = 1;
AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;
PieCtrlRegs.PIEACK.all = PIEACK_GROUP1;
return;
