Embed Size (px)
Citation preview
i
APERFEIÇOAMENTO DE UM SENSOR DE IMAGENS
CMOS PARA OPERAÇÃO COM TEMPO DE
INTEGRAÇÃO VARIÁVEL
Gabriel de Oliveira Beskow
Projeto de Graduação apresentado ao Curso de
Engenharia Eletrônica e de Computação da Escola
Politécnica, Universidade Federal do Rio de
Janeiro, como parte dos requisitos necessários à
obtenção do título de Engenheiro.
Orientador: José Gabriel Rodríguez Carneiro
Gomes
Rio de Janeiro
Agosto de 2015
ii
APERFEIÇOAMENTO DE UM SENSOR DE IMAGENS
CMOS PARA OPERAÇÃO COM TEMPO DE
INTEGRAÇÃO VARIÁVEL
Gabriel de Oliveira Beskow
PROJETO DE GRADUAÇÃO SUBMETIDO AO CORPO DOCENTE DO CURSO
DE ENGENHARIA ELETRÔNICA E DE COMPUTAÇÃO 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 ELETRÔNICO E DE COMPUTAÇÃO
Autor:
_________________________________________________
Gabriel de Oliveira Beskow
Orientador:
_________________________________________________
Prof. José Gabriel Rodríguez Carneiro Gomes, Ph. D.
Examinador:
_________________________________________________
Prof. Antonio Petraglia, Ph. D.
Examinador:
_________________________________________________
Prof. Carlos Fernando Teodósio Soares, D. Sc.
Rio de Janeiro – RJ, Brasil
Agosto de 2015
iii
UNIVERSIDADE FEDERAL DO RIO DE JANEIRO
Escola Politécnica – Departamento de Eletrônica e de Computação
Centro de Tecnologia, bloco H, sala H-217, Cidade Universitária
Rio de Janeiro – RJ CEP 21949-900
Este exemplar é de propriedade da Universidade Federal do Rio de Janeiro, que
poderá incluí-lo em base de dados, armazená-lo em computador, microfilmá-lo ou adotar
qualquer forma de arquivamento.
É permitida a menção, reprodução parcial ou integral e a transmissão entre
bibliotecas deste trabalho, sem modificação de seu texto, em qualquer meio que esteja
ou venha a ser fixado, para pesquisa acadêmica, comentários e citações, desde que sem
finalidade comercial e que seja feita a referência bibliográfica completa.
Os conceitos expressos neste trabalho são de responsabilidade do(s) autor(es).
iv
DEDICATÓRIA
Dedico este projeto à memória de meu tio Mílton Antônio de Oliveira, o qual
infelizmente, não pode fazer parte deste momento tão especial. É impossível não tentar
imaginar sua reação. Tenho a certeza que estaria tão feliz como eu estou agora. Levarei
sempre comigo sua alegria e carinho. Seu jeito simples de ver a vida.
v
AGRADECIMENTO
Em primeiro lugar agradeço à minha mãe, Eliane Cristina de Oliveira, por ter me
dado a oportunidade de me dedicar a este curso. Sei o quanto foi difícil e a quantidade
de pessoas que não possuem a mesma sorte. Agradeço pelo apoio e incentivo, por ser
meu chão e meu porto, meu abrigo durante as tempestades que vieram e que ainda virão.
Agradeço ao meu orientador, Professor José Gabriel Rodríguez Carneiro Gomes,
por me guiar durante este projeto, por sua paciência e disposição em ajudar, por colocar
sobre mim um fardo que eu conseguiria carregar.
Agradeço aos professores da UFRJ pelos conhecimentos transmitidos e aos
colegas de curso por tornarem mais amenos estes longos anos. Aqui, um agradecimento
especial aos meus amigos Igor Cunha Bragança, Bruno Ramos e Álvaro da Silva Júnior,
parceiros de laboratório e projetos durante o curso.
Finalmente, agradeço aos companheiros de trabalho e amigos que fiz durante
meus dois anos de estágio na equipe de OSS da Oi pelos conhecimentos práticos
adquiridos e os bons momentos vividos.
Existe um pouco de todos vocês neste trabalho.
vi
RESUMO
Este projeto trata da implementação de um método para transferir o valor de um
parâmetro de um computador para um microcontrolador PIC. O parâmetro é o tempo de
integração que se deseja para um fotodiodo e será utilizado pelo microcontrolador para
gerar os sinais de controle de um sensor de imagens CMOS implementado no PADS
(Laboratório de Processamento Analógico de Digital de Sinais, COPPE/UFRJ).
No computador, a interface gráfica de usuário define as ações a serem
executadas pelo PIC e interpreta os resultados obtidos. O microcontrolador recebe os
comandos da interface, gera os sinais de controle para o funcionamento do sensor e
envia os resultados ao computador. Esta comunicação é feita via USB.
Neste trabalho, foram feitas as alterações no código-fonte da interface gráfica de
usuário e no firmware do PIC para que o sistema funcione com o novo tempo de
integração. Além disso, foi feita a validação do método no circuito de testes do sistema.
Os resultados obtidos mostraram que o microcontrolador passou a utilizar o
novo valor do parâmetro, lido de um arquivo-texto e enviado pela interface gráfica de
usuário, para gerar os sinais de controle do sensor de imagens. Apesar disso, houve um
acréscimo nos valores medidos devido ao tempo de execução do laço de repetição que
foi implementado para gerar o tempo de integração desejado. O maior erro relativo
medido experimentalmente é de seis por cento para o método escolhido.
Palavras-Chave: sensor CMOS, USB, microcontrolador, interface gráfica.
vii
ABSTRACT
This project is the implementation of a method that transfers the value of a
parameter from a computer to a PIC microcontroller. The parameter is the integration
period wanted for a photodiode and it will be used by the microcontroller to generate
the control signals of a CMOS image sensor implemented at PADS (Laboratório de
Processamento Analógico de Digital de Sinais, COPPE/UFRJ).
On the computer, the graphical user interface defines the actions to be
performed by the PIC and interprets the results. The microcontroller receives commands
from the interface, generates the control signals for the sensor operation and sends the
results to the computer. This communication is done via USB.
In this project, changes were made in the graphical user interface source code
and in the PIC firmware for the system to function with the integration time.
Furthermore, the method validation was made in the experimental circuit test set-up.
The results showed that the microcontroller has been using the new parameter
value, read from a text file and sent by the graphical user interface, to generate the
image sensor control signals. Nevertheless, there was a slight increase in the measured
figures due to the repetition loop runtime, implemented to generate the desired
integration time. The largest experimentally measured error is six percent for the chosen
method.
Keywords: CMOS camera, USB, microcontroller, graphical interface.
viii
SIGLAS
CCD – Charge Coupled Device
CDS – Correlated Digital Sampling
CI – Circuito Integrado
CMOS – Complementary Metal Oxide Semiconductor
COPPE – Instituto Alberto Luiz Coimbra de Pós-Graduação e Pesquisa de Engenharia
DEL – Departamento de Eletrônica
DPCM – Differential Pulse Code Modulation
EPOLI – Escola Politécnica
MTF – Modulation Transfer Function
PADS – Laboratório de Processamento Analógico e Digital de Sinais
PEE – Programa de Engenharia Elétrica
PIC – Peripheral Interface Controller
UFRJ – Universidade Federal do Rio de Janeiro
USB – Universal Serial Bus
As seguintes expressões não pertencem ao idioma português, mas serão escritas
sem o uso de caracteres em itálico, por que seu uso agora ser muito frequente em nosso
idioma: chip; clock; firmware; pixel; pixels; software.
ix
Sumário
Capítulo 1 ........................................................................................................................ 1
Introdução ....................................................................................................................... 1
1.1 – Tema ................................................................................................................................. 1
1.2 – Objetivo ............................................................................................................................ 1
1.3 – Justificativa ....................................................................................................................... 2
1.4 – Metodologia ..................................................................................................................... 2
1.5 – Descrição .......................................................................................................................... 3
Capítulo 2 ........................................................................................................................ 4
Fundamentos Teóricos ................................................................................................... 4
2.1 – O Imageador CMOS .......................................................................................................... 4
2.2 – Circuito de Leitura do Fotodiodo ..................................................................................... 5
2.3 – O Chip Fabricado .............................................................................................................. 6
2.4 – O Aparato de Testes ......................................................................................................... 7
2.5 – O Circuito de Controle ...................................................................................................... 8
2.6 – A Interface Gráfica de Usuário ......................................................................................... 9
2.7 – O Firmware do Microcontrolador .................................................................................. 11
Capítulo 3 ...................................................................................................................... 13
Métodos ......................................................................................................................... 13
3.1 – Origem do Parâmetro ..................................................................................................... 13
3.2 – Definição e Obtenção do Parâmetro .............................................................................. 14
3.3 – Envio do Parâmetro pela Interface Gráfica .................................................................... 15
3.4 – Recebimento do Parâmetro pelo Microcontrolador ...................................................... 16
3.5 – O Uso do Parâmetro pelo Sensor CMOS ........................................................................ 17
Capítulo 4 ...................................................................................................................... 19
Resultados ..................................................................................................................... 19
4.1 – O Sistema Anterior ......................................................................................................... 19
4.2 – O Novo Sistema .............................................................................................................. 21
4.3 – Aumentando o Tamanho do Passo ................................................................................ 24
Capítulo 5 ...................................................................................................................... 28
Conclusões ..................................................................................................................... 28
Bibliografia .................................................................................................................... 29
x
Lista de Figuras
Figura 1: Circuito de leitura do fotodiodo ..................................................................................... 5
Figura 2: Formas de onda dos sinais Reset, P1 e P2 ao longo do tempo ...................................... 6
Figura 3: Fotos do chip tiradas por um microscópio óptico (a) e por uma câmera (b) ................. 7
Figura 4: Diagrama de blocos do sistema de comunicação ........................................................... 7
Figura 5: Diagrama esquemático do circuito de controle .............................................................. 8
Figura 6: Interface gráfica de usuário............................................................................................ 9
Figura 7: Fluxograma do software da interface gráfica .............................................................. 10
Figura 8: Fluxograma do firmware ............................................................................................. 12
Figura 9: Código-fonte para leitura do arquivo-texto. ................................................................ 14
Figura 10: Arquivo ―definicoes.h‖ .............................................................................................. 15
Figura 11: Trecho do código-fonte para o envio do parâmetro ................................................... 16
Figura 12:Trecho do códifo-fonte da função ―user.h‖ no firmware ............................................ 16
Figura 13: Trecho do código-fonte que recebe e altera o tempo de integração........................... 17
Figura 14: Trecho do código-fonte que gera o tempo de integração ........................................... 18
Figura 15: Trecho do código-fonte em que P1 e P2 são configurados ........................................ 19
Figura 16: Pinagem do PIC 18LF4550 ....................................................................................... 20
Figura 17: Tempo de integração é de 800 µs .............................................................................. 20
Figura 18: Trecho do código-fonte onde é gerado o tempo de integração de 800 µs ................. 21
Figura 19: Tempo de Integração é de 126 µs .............................................................................. 22
Figura 20: Tempo de integração é de 544 µs .............................................................................. 22
Figura 21: Tempo de integração é de 860 µs .............................................................................. 22
Figura 22: Tempo de integração é de 1280 µs ............................................................................ 23
Figura 23: Tempo de integração é de 1910 µs ............................................................................ 23
Figura 24: Tempo de integração é de 2640 µs ............................................................................ 23
Figura 25: Tempo de integração é de 3160 µs ............................................................................ 24
Figura 26: Tempo de integração é de 106 µs .............................................................................. 25
Figura 27: Tempo de integração é de 512 µs .............................................................................. 25
Figura 28: Tempo de integração é de 820 µs .............................................................................. 25
Figura 29: Tempo de integração é de 1230 µs ............................................................................ 26
Figura 30: Tempo de integração é de 1840 µs ............................................................................ 26
Figura 31: Tempo de integração é de 2560 µs ............................................................................ 26
Figura 32: Tempo de integração é de 3060 µs ............................................................................ 27
1
Capítulo 1
Introdução
1.1 – Tema
Este trabalho tem como origem um sensor de imagens CMOS, implementado e
testado no PADS (Laboratório de Processamento Analógico de Digital de Sinais,
COPPE/UFRJ) e detalhado no Projeto de Graduação de Fernanda Duarte Vilela Reis de
Oliveira [1] e na Dissertação de Mestrado de Hugo de Lemos Haas [2].
Existe, no laboratório, um circuito de teste do sensor ligado a um computador
através de uma porta USB. No computador, o usuário controla as tarefas realizadas pelo
circuito através de uma interface gráfica. Para gerar os sinais de controle do chip e ler
seus dados de saída existe, no circuito de teste, um microcontrolador PIC com interface
USB. O computador também recebe e grava em um arquivo a sequência de bits de saída
do chip, enviados pelo PIC. Toda a comunicação entre computador e o
microcontrolador é feita via interface USB.
Assim, neste trabalho abordaremos o sensor de imagens CMOS, o
microcontrolador PIC, seu firmware e a sua comunicação com computadores via
interface USB, além da interface gráfica de usuário e sua programação.
1.2 – Objetivo
O projeto tratará da implementação de um método que transfere do computador
o valor de um parâmetro, no caso o tempo de integração, para o microcontrolador PIC.
Para isso, serão feitas as alterações no código da interface gráfica de usuário e no
firmware do microcontrolador. O objetivo é que o sistema passe a utilizar o valor
recebido para gerar o intervalo de tempo entre os sinais de controle necessários para a
operação do sensor CMOS. Por fim, será feita a validação do método no circuito de
testes em laboratório e serão apresentados os resultados obtidos com intuito de verificar
se o nosso objetivo foi alcançado.
2
1.3 – Justificativa
Existe uma forma muito usada para avaliar sistemas ópticos, visando medir as
limitações de desempenho, chamada de Modulation Transfer Function ou MTF [3]. Ela
mede a fidelidade com que o sistema reproduz detalhes do objeto na imagem capturada.
A MTF é função de um parâmetro chamado tempo de integração (tempo que o sensor
fica exposto à luz até que a amostragem seja realizada). Este tempo é o intervalo entre
dois pulsos de controle, chamados no projeto da câmera de P1 e P2, gerados pelo
microcontrolador. Este intervalo foi escolhido e fixado em 800 µs no sistema de
controle existente para o sensor de imagens CMOS.
Há o interesse em tornar o sistema automático quanto ao tempo de integração,
permitindo que a MTF seja maximizada para diferentes condições de iluminação sem
interferência do usuário. O objetivo é encontrar um valor ótimo para o tempo de
integração em determinada condição de iluminação. Assim, o tempo de integração que
atualmente é fixo passará a ser variável. Este valor será determinado, enviado ao
microcontrolador e utilizado para a ativação dos sinais de controle do sensor. Este
sistema de controle será implementado em um trabalho futuro.
1.4 – Metodologia
Como já existe a interface gráfica de usuário e a comunicação via interface USB
com o microcontrolador, será estudada a melhor maneira para transferir o parâmetro
desejado com poucas modificações no sistema existente.
Em primeiro lugar, é necessário o entendimento desse sistema. Ele é dividido
em dois programas: um que é gravado no microcontrolador e o outro que implementa,
no computador, a interface gráfica de usuário. Será também estudado como esses dois
programas se comunicam através da interface USB.
Então, será definido e implementado um método para transmitir, da interface
gráfica de usuário, um valor de tempo de integração para o microcontrolador. Serão
também implementadas as mudanças no sistema de controle do sensor CMOS para que
este passe a atuar com o valor recebido do computador.
Por fim, será feita a validação do método em laboratório. Para isso, será
utilizado o aparato de testes descrito na Seção 2.4 onde será verificado se os resultados
obtidos estão de acordo com o esperado.
3
1.5 – Descrição
No Capítulo 2 será apresentada a câmera existente no PADS que serviu de base
para a implementação deste projeto. Este capítulo constitui o embasamento teórico que
torna possível a resolução do problema proposto.
O Capítulo 3 apresenta o desenvolvimento do projeto. Serão mostrados os
métodos aplicados, os problemas encontrados e as soluções propostas.
Os resultados obtidos são apresentados e analisados no Capítulo 4. Nele também
serão explicados os testes realizados no laboratório. Será mostrado o comportamento do
sistema anterior, comparado ao atual para verificar se o objetivo final foi alcançado.
O Capítulo 5 mostra a conclusão deste trabalho.
4
Capítulo 2
Fundamentos Teóricos
Neste capítulo abordaremos os temas necessários ao entendimento do projeto da
câmera CMOS que já existia no PADS. Este entendimento se fez necessário e foi a
maior dificuldade encontrada neste trabalho. Ela consistiu em entender a lógica e a
estrutura de um projeto já implementado e, assim, tornar possível o seu
aperfeiçoamento. Um dos objetivos foi alterar pouco a estrutura do sistema a fim de
aproveitar ao máximo o trabalho já feito.
Abordaremos o imageador CMOS, explicaremos como é feita a leitura do
fotodiodo, como foi fabricado e funciona o chip projetado, o circuito desenvolvido para
testá-lo e para controlá-lo, a interface gráfica de usuário e o código que faz a
comunicação entre o computador e o PIC, e finalmente, o programa que gera os sinais e
comandos necessários no microcontrolador para que o sensor CMOS funcione da
maneira desejada.
2.1 – O Imageador CMOS
Anos atrás, quando a fotografia digital começava a se disseminar, os sensores
CMOS, de produção mais barata e resolução limitada, eram sinônimo de câmera
popular. Já os CCDs, então capazes de resoluções mais altas do que os CMOS do
mesmo período e muito menos suscetíveis a ruído, ficaram tradicionalmente associados
às câmeras ―de verdade‖. Hoje em dia os sensores CMOS alcançaram em termos de
qualidade de imagem, nível de ruído e consumo de potência os sensores CCDs [5].
Uma diferença entre CCD e CMOS é onde os sinais elétricos gerados em cada
um dos fotodiodos responsáveis por capturar os fótons que compõem uma imagem são
amplificados, convertidos e digitalizados. Nos CCDs, isso acontece fora do sensor
propriamente dito, enquanto nos CMOS o processo se dá separadamente para cada pixel
da imagem, bem no ponto do sensor em que ele é registrado.
No PADS foi implementado e testado um imageador CMOS de 32x32 pixels
capaz de realizar a compressão, com perdas, de imagens em escala de cinza no plano
5
focal. O sensor possui saída digital e cada bloco de 4x4 pixels é representado por 15
bits. O método de compressão utiliza quantização vetorial e DPCM. Para saber mais
detalhes sobre o método de compressão consulte [1] e [2].
2.2 – Circuito de Leitura do Fotodiodo
A princípio precisamos entender como funciona a leitura do fotodiodo, ou seja,
o procedimento necessário para tirar uma foto. São utilizados três sinais de controle
gerados pelo microcontrolador – Reset, P1 e P2. Para entendimento do leitor, a Figura 1
mostra o circuito de leitura e como estes sinais são aplicados a ele.
Figura 1: Circuito de leitura do fotodiodo
O sinal de Reset fica em nível lógico alto por 80 µs, tempo necessário para
carregar a capacitância associada ao catodo do fotodiodo. Esta capacitância irá se
descarregar de acordo com a intensidade da luz incidente. O tempo que o fotodiodo fica
exposto até que a amostragem seja realizada, ou seja, o intervalo entre as descidas dos
sinais P1 e P2, é o tempo de integração do sensor.
São realizadas uma amostragem no início e outra no final da integração do
fotodiodo. A primeira é feita através do sinal P1 logo após o sinal de Reset ir para o
nível lógico baixo. O Sinal P2 é desligado após 800 µs que é o tempo de integração
escolhido no projeto do circuito de controle. A Figura 2 ilustra o comportamento dos
sinais Reset, P1 e P2 ao longo do tempo através de suas formas de onda.
6
Figura 2: Formas de onda dos sinais Reset, P1 e P2 ao longo do tempo
Essa técnica de leitura, que consiste em realizar a diferença entre uma
amostragem inicial e uma final, é chamada de correlated double sampling (CDS) e tem
como objetivo a redução de ruído. Historicamente, a qualidade de imagem gerada pelos
sensores CMOS aumentou significativamente após a introdução do CDS, permitindo
que a qualidade de imagem gerada alcançasse a dos sensores CCDs [1].
2.3 – O Chip Fabricado
O circuito integrado projetado no laboratório possui 8x8 blocos de 4x4 pixels.
Ele tem saída serial, ou seja, os bits de saída são ligados a um único barramento. A
saída da matriz de pixels é digital e comprimida. A Figura 3 mostra fotos tiradas do chip
fabricado. Além do bloco principal, foram acrescentadas algumas estruturas de teste
para caracterizá-lo.
Existe um par de pixels nos quatro cantos da matriz principal. O objetivo é
verificar se a matriz está iluminada de maneira uniforme, encontrar a curva de resposta
do fotodiodo e confirmar a importância da técnica CDS. Por isso, um dos pixels possui
saída que é dada pela diferença entre uma amostragem inicial e uma final (P1 e P2) e no
outro a saída é dada somente pela amostragem final do fotodiodo, ou seja, sem CDS.
Eles possuem os mesmos sinais de controle da matriz principal e são chamados de
pixels de teste no sistema do imageador CMOS.
Existe também um pixel independente separado do restante do circuito. Ele é um
pixel sem CDS em que os sinais de controle (P2_I e #P2_I) não são os mesmos do
restante do circuito. Os pinos de leitura do pixel independente estão diretamente ligados
aos pads do circuito integrado e o objetivo é verificar o estado do chip caso ele não
apresente nenhuma resposta.
7
(a) (b)
Figura 3: Fotos do chip tiradas por um microscópio óptico (a) e por uma câmera (b)
Existe ainda uma terceira estrutura de testes que são dois blocos de 4x4 pixels,
um com CDS e o outro sem CDS, que também servem para descobrir falhas caso o chip
não apresente resposta. Essa estrutura também é controlada por Reset, P1 e P2 e é
chamada de blocos de teste.
2.4 – O Aparato de Testes
Foi projetado e montado em [1] um aparato de testes para o sensor de imagens.
Ele consiste em um circuito capaz de gerar os sinais de controle do circuito integrado,
gravar os bits de saída e enviar esses bits para o computador que realizará a
decodificação da imagem. Para a realização destas tarefas foi usado um
microcontrolador PIC 18LF4550 fabricado pela Microchip Solutions [6] que possui
interface USB.
O circuito é controlado por um computador através de uma interface gráfica de
usuário. Nela é possível escolher a tarefa a ser realizada pelo chip, como tirar uma foto,
ativar uma estrutura de teste ou trabalhar no modo Viewfinder, detalhadas na Seção 2.5.
A Figura 4 mostra o diagrama de blocos que representa a comunicação entre o PIC, o
sensor CMOS e o computador.
Figura 4: Diagrama de blocos do sistema de comunicação
8
O firmware utilizado para programar o microcontrolador, assim como a interface
gráfica de usuário foram programados com base no USB Framework que são exemplos
disponíveis no site da Microchip [6] que implementam a comunicação via interface
USB entre o computador e o PIC.
2.5 – O Circuito de Controle
A Figura 5 representa o diagrama esquemático do circuito de controle do sensor
CMOS. O chip está ligado à alimentação através da chave Sw1 controlada pelo PIC. O
microcontrolador liga o chip CMOS fechando esta chave quando recebe algum
comando da interface gráfica de usuário. Os sinais S1, S2 e S3 selecionam a linha da
matriz de pixels a ser lida no imageador.
Figura 5: Diagrama esquemático do circuito de controle
O PIC gera os sinais de controle Reset, P1 e P2 utilizados na leitura do
fotodiodo. Os sinais de Load e Clock controlam o registrador de deslocamento para a
leitura dos bits gerados por cada linha dos blocos.
Os resistores e os outros sinais que não foram citados anteriormente fazem parte
das estruturas de testes descritas na Seção 2.3 e não serão aprofundados neste trabalho.
Detalhes sobre o seu funcionamento podem ser encontrados em [1].
9
2.6 – A Interface Gráfica de Usuário
Para controlar o PIC existe uma interface gráfica mostrada na Figura 6. Ela foi
escrita utilizando a linguagem de programação C++ e a biblioteca gráfica MSDN,
desenvolvida pela Microsoft.
Figura 6: Interface gráfica de usuário
A interface foi desenvolvida em [1] e posteriormente alterada no projeto final de
Leandro d’Oliveira do Rêgo [4] para que fosse possível o aumento da taxa de captura de
quadros da câmera. Para isso, foi implementado um novo decodificador. Este trabalho
trata da comunicação entre a interface gráfica e o microcontrolador PIC. Portanto, essas
mudanças não serão detalhadas. Para saber detalhes consulte [4]. A Figura 7 mostra o
fluxograma do código executado pela versão original da interface encontrado em [1].
No início do programa são definidas as configurações para a comunicação via
interface USB com o microcontrolador. Após isso, é verificado se ele está conectado ao
computador. Se a resposta for positiva, os botões são ativados e o programa entra em
um laço, que verifica a cada repetição se algum deles foi clicado.
O primeiro botão, ―Ativar bloco principal‖, faz com que o programa da interface
gráfica envie ao microcontrolador o comando para ligar a matriz de pixels principal e
realizar a leitura dos resultados. Os bits resultantes da compressão de uma foto são
recebidos e gravados em um arquivo-texto que será usado pelo decodificador.
O segundo botão faz com que o pixel independente seja ativado. Este comando é
enviado repetidamente até que o botão de parar seja selecionado. Isto serve para que o
sinal de saída do pixel independente possa ser observado no osciloscópio. O botão
10
―Ativar pixels de teste‖ funciona da mesma maneira para que os pares de pixels de teste
também possam ser observados no instrumento.
Figura 7: Fluxograma do software da interface gráfica
O botão ―Ativar blocos de teste‖ realiza a leitura dos 15 bits do bloco de teste
com CDS e outros 15 bits sem CDS. Os 30 bits resultantes são enviados para o
computador e gravados em um arquivo-texto.
O modo ―Iniciar disparos‖ faz com que qualquer um dos comandos citados
anteriormente seja repetido um determinado número de vezes. O comando é escolhido
11
na caixa de seleção à esquerda e a quantidade de repetições é definida na caixa de texto
à direita do botão.
Por fim, o modo ―Viewfinder‖ realiza o comando do botão ―Ativar bloco
principal‖ repetidamente. Este é o modo utilizado junto com o decodificador projetado
em [4]. Ele acessa o arquivo-texto gravado pela interface gráfica. Através deste modo é
possível observar com um pequeno atraso as imagens capturadas pelo chip, o que nos
permite alinhar a imagem e fazer ajustes de foco e luminosidade.
2.7 – O Firmware do Microcontrolador
O programa do PIC é mais complexo que o da interface gráfica. Como já foi
dito, foi utilizado um exemplo implementado pelo fabricante do microcontrolador. Nele,
foram feitas as configurações do dispositivo e da interface de comunicação USB.
Assim, com as configurações implementadas, foi necessário modificar algumas funções
para que o sistema de controle operasse da maneira desejada. Podemos observar o
fluxograma do código escrito na Figura 8 que também pode ser encontrado em [1].
Primeiro, são definidas as entradas analógicas e digitais do microcontrolador e
os pinos de saída analógicas e digitais. São inicializadas as saídas digitais e é
configurada a comunicação USB para verificar se existe um dispositivo ligado a ela.
É a interface gráfica que definirá o modo de operação do chip através do envio
ao microcontrolador de um vetor de bytes. A primeira posição deste vetor contém o
valor que define a operação a ser realizada. Os comandos que o PIC pode executar são
os vistos na interface. O programa executa um laço infinito, verificando a cada repetição
se o computador enviou alguma informação. Uma função do tipo switch faz a seleção
onde cada case representa um modo e executa as operações necessárias no circuito.
O comando ―Ativar bloco principal‖ é usado para tirar uma foto. Ao recebê-lo o
microcontrolador gera os sinais de leitura do fotodiodo e de controle do registrador de
deslocamento, realizando a leitura de uma linha da matriz de pixels. A linha a ser lida
vem também no vetor de bytes. O tempo de integração do fotodiodo não pode variar de
uma leitura pra outra, por isso todos os sinais de controle são executados dentro de uma
interrupção do microcontrolador. Assim, não há interferência de outros processos
executados no PIC.
O comando ―Ativar o pixel independente‖ faz com que o microcontrolador gere
os sinais necessários para o teste do mesmo. Os sinais de controle são: Reset_I, P2_I e
12
#P2_I. A saída é observada utilizando um osciloscópio para medir a tensão no terminal
do resistor ligado ao pino do chip.
Figura 8: Fluxograma do firmware
Os dois comandos restantes, ―Ativar blocos de teste‖ e ―Ativar pixels de teste‖,
geram os mesmos sinais de controle do primeiro comando, necessário para ligar a
matriz de pixels principal. No caso dos pixels de teste as saídas serão observadas no
osciloscópico como o pixel independente. Nos blocos de teste o PIC irá ler e enviar ao
computador os 30 bits de saída, sendo 15 bits para o bloco com CDS e 15 bits para o
bloco sem CDS. O computador grava esses bits em um arquivo-texto que será utilizado
pelo decodificador.
13
Capítulo 3
Métodos
Neste capítulo serão expostos os problemas encontrados e as soluções propostas
durante este trabalho. Perceberemos que as alterações necessárias no projeto do sistema
de controle da câmera CMOS foram poucas. Porém, o objetivo era justamente esse.
Após analisar e entender o que havia sido feito no projeto original foi preciso decidir
onde e como seria modificado o sistema para alcançar o objetivo proposto.
Mostraremos como foi definida a origem do tempo de integração, sua
especificação, como ele é obtido e enviado ao microcontrolador, como o PIC recebe
este valor e como ele o utiliza para controlar o sensor CMOS.
3.1 – Origem do Parâmetro
O primeiro problema encontrado foi em relação à origem do parâmetro a ser
transmitido. Uma solução proposta seria modificar a interface gráfica, adicionando um
novo campo de texto, para que o usuário definisse o tempo de integração. Porém, não
era mais possível acrescentar botões ou campos na interface gráfica, o que, pelo
conhecimento que temos no laboratório, parece ser devido a uma limitação existente na
versão do Microsoft Visual Studio — software utilizado para implementar a solução.
Ou seja, por esta hipótese, para acrescentar um botão seria necessário retirar algum
outro existente. Isto implicaria em jogar uma parte do trabalho feito nos projetos
anteriores fora. Desta maneira, esta solução foi descartada. Outra ideia seria fazer uma
nova versão da interface usando aplicativos gratuitos, tais como Qt ou wxWidgets, mas
esta possibilidade não foi tratada neste projeto.
Foi, então, proposto que esse valor fosse lido de um arquivo-texto. Essa solução
fez todo o sentido, pois a interface gráfica já manipulava alguns arquivos deste tipo.
Assim, o programa ficaria coerente. Além disso, existia a ideia de implementar um
método de controle onde o tempo de integração fosse definido de acordo com as
condições de iluminação da imagem a ser capturada. Esse controle seria realizado por
um outro sistema a ser implementado em um trabalho futuro. Portanto, faria todo o
sentido que este método escrevesse o valor encontrado em um arquivo-texto,
14
possibilitando a integração com a interface gráfica sem depender do usuário. Pelos
motivos expostos, esta foi a solução adotada.
3.2 – Definição e Obtenção do Parâmetro
No projeto original o valor do tempo de integração era fixado em 800 µs. Para o
novo sistema foi decidido que o parâmetro estaria dentro de uma faixa de valores entre
100 µs e 3000 µs. Foi decidido também que sempre seriam enviados quatro bytes para o
microcontrolador. Assim, se o valor estivesse entre 100 µs e 999 µs, ou seja, tivesse
apenas três caracteres, seria adicionado um zero como primeiro caractere.
Como já foi dito, este valor será definido em um arquivo-texto. Assim, em
primeiro lugar, precisamos realizar a leitura do tempo de integração neste arquivo que
foi chamado de “tempoIntegracao.txt”. A Figura 9 mostra o trecho do programa que
usado para obter este valor.
#include <fstream>
ifstream arquivoTempo;
char tempInteg[5];
int index;
arquivoTempo.open("tempoIntegracao.txt");
if(arquivoTempo.is_open()){
arquivoTempo.get(tempoInteg,5);
if(arquivoTempo.gcount()==3){
tempoInteg[3]=tempoInteg[2];
tempoInteg[2]=tempoInteg[1];
tempoInteg[1]=tempoInteg[0];
tempoInteg[0]='0';
}
arquivoTempo.close();
}
else{
tempoInteg[0]='0';
tempoInteg[1]='8';
tempoInteg[2]='0';
tempoInteg[3]='0';
}
Figura 9: Código-fonte para leitura do arquivo-texto.
Foi utilizada a biblioteca fstream que é um manipulador de fluxo de dados de
arquivos. Ela permite ler e escrever em modo texto ou binário. Dentro desta biblioteca
existe a classe ifstream que define um fluxo a ser usado para ler dados de caracteres de
15
byte único em série. Caso o arquivo-texto contendo o tempo de integração desejado não
exista ou, por algum motivo, não consiga ser aberto, o sistema irá, por definição,
trabalhar com o valor do projeto original de 800 µs.
O método get foi utilizado para a leitura. Por especificação, o tempo de
integração teria três ou quatro caracteres – entre 100 µs e 3000 µs. Por isso, foi passado
o número cinco como argumento. Desta forma, a função realizará a leitura de, no
máximo, quatro caracteres até encontrar o fim da linha ou o final do arquivo. O método
gcount, que retorna o número de bytes lidos na última iteração da função get, foi
utilizado como condição para adicionar o quarto caractere aos casos necessários.
Este trecho do código-fonte foi escrito no arquivo “form.h”, que implementa a
interface gráfica de usuário, antes do programa entrar no laço infinito que espera o
comando da interface. Isto foi feito para evitar que o arquivo-texto fique sendo aberto e
fechado para a leitura durante toda a execução do sistema.
3.3 – Envio do Parâmetro pela Interface Gráfica
Como foi dito na Seção 2.7, é a interface gráfica que definirá o modo de
operação do chip. Ela envia ao microcontrolador um vetor de bytes. A primeira posição
deste vetor contém o valor do comando a ser executado. Assim, foi preciso definir no
arquivo “definicoes.h” uma nova constante para representar o comando de leitura do
valor do novo tempo de integração. A Figura 10 mostra o arquivo já modificado.
#ifndef DEFINICOES_H
#define DEFINICOES_H
#define ATIVAR_BLOCO_PRINCIPAL 0x31
#define ATIVAR_PIXEL_INDEP 0x32
#define ATIVAR_BLOCOS_TESTE 0x33
#define ATIVAR_PIXELS_TESTE 0x34
#define DEFINIR_TEMPO_INTEGRACAO 0X35
#endif
Figura 10: Arquivo “definicoes.h”
Todo o processo de comunicação da interface com o microcontrolador é baseado
nos exemplos fornecidos pela Microchip Solutions. Assim, todas as configurações e as
bibliotecas utilizadas foram implementadas pelo fabricante do PIC. Para que o sistema
funcione como desejamos apenas foram feitas as modificações necessárias.
16
A biblioteca usada para a comunicação com o microcontrolador é a MPUSBAPI
e a função utilizada para enviar dados da interface para ele é a MPUSBWrite. Um laço
transfere o tempo de integração à variável Buffer que é enviada ao PIC. A Figura 11
mostra o trecho do código-fonte responsável pelo envio do parâmetro.
for(index=0;index<=3;index++)
Buffer[index+2]=tempoInteg[index];
Buffer[0]=DEFINIR_TEMPO_INTEGRACAO
MPUSBWrite(EP1OUTHandle, Buffer, 6, &ActualLength, INFINITE);
Figura 11: Trecho do código-fonte para o envio do parâmetro
A função MPUSBWrite recebe cinco argumentos. O primeiro identifica o
endpoint para onde os dados serão enviados, no caso o endereço do microcontrolador. O
segundo é a variável Buffer – vetor de bytes que contém os dados. O terceiro é um
número que representa a quantidade de bytes que serão transferidos. O quarto aponta o
número de bytes que a função escreveu e o último define um intervalo de tempo para a
execução da função.
3.4 – Recebimento do Parâmetro pelo Microcontrolador
O firmware do microcontrolador também foi escrito baseado em um exemplo
fornecido pelo fabricante para um dispositivo genérico. Para atender o nosso objetivo,
três arquivos sofreram modificações. A primeira alteração é feita no arquivo “user.h” e
consiste em adicionar a constante DEFINIR_TEMPO_INTEGRACAO, como foi feito
dentro do programa da interface gráfica de usuário. A Figura 12 mostra o trecho do
código-fonte do firmware em que é feita esta definição.
typedef enum
{
READ_VERSION = 0x00,
ATIVAR_BLOCO_PRINCIPAL = 0x31,
ATIVAR_PIXEL_INDEP = 0x32,
ATIVAR_BLOCOS_TESTE = 0x33,
ATIVAR_PIXELS_TESTE = 0x34,
DEFINIR_TEMPO_INTEGRACAO = 0x35,
RD_POT = 0x37,
RESET = 0xFF
}TYPE_CMD;
Figura 12:Trecho do códifo-fonte da função “user.h” no firmware
17
No arquivo “user.c” foi modificada a função ServiceRequests. Nela é executado
o switch que alterna entre os comandos que podem ser passados pela interface gráfica ao
microcontrolador no vetor de bytes. Foi adicionado um novo case para alterar o valor do
tempo de integração. O trecho do código pode ser visto na Figura 13.
int valorTempoInt;
case DEFINIR_TEMPO_INTEGRACAO:
{
int index;
unsigned char tempoChar[4];
int tempoInt[4];
for(index=0;index<=3;index++){
tempoChar[index]==OUTPacket._byte[index+2];
tempoInt[index]=tempoChar[index]-48;
}
valorTempoInt=tempoInt[0]*1000+tempoInt[1]*100+tempoInt[2]*10+tempoInt[3];
}
break;
Figura 13: Trecho do código-fonte que recebe e altera o tempo de integração
O valor enviado pela interface gráfica é recebido no objeto OUTPacket.
Passamos esse valor para um vetor de caracteres. Após isso, esse valor é convertido para
um vetor de inteiros. Para isso, basta subtrairmos o valor 48 de cada caractere, pois na
tabela ASCII eles são representados por valores inteiros deslocados de quarenta e oito
unidades. Para termos o valor total na base decimal multiplicamos os valores de cada
caractere por mil, cem, dez respectivamente e somamos os resultados.
3.5 – O Uso do Parâmetro pelo Sensor CMOS
Como já foi dito na Seção 2.7 o tempo de integração do fotodiodo não pode
variar de uma leitura pra outra, por isso todos os sinais de controle são executados
dentro de uma interrupção do microcontrolador. Assim, não há interferência de outros
processos executados no PIC.
A interrupção é executada no arquivo “main.c” dentro da função
YourHighPriorityISRCode. Para esperar o tempo de integração utilizamos a função do
compilador de delay. Ela espera um certo número de instruções (TCY), onde cada
18
instrução dura quatro ciclos de clock (detalhes sobre esta abordagem serão dados no
Capítulo 4). O microcontrolador trabalha com uma frequência de clock de 48 MHz.
A princípio, foi estabelecido que os valores do tempo de integração seriam
múltiplos inteiros de cinquenta. Esta decisão foi necessária, pois é preciso estabelecer o
tamanho do passo que será dado para gerar o atraso especificado. Assim, foi feito um
laço que executa a função Delay10TC(60), ou seja, 50 µs de atraso a cada repetição até
que o valor desejado seja atingido.
Declaramos a variável valorTempoInt como do tipo extern. Assim, trazemos o
valor que é atribuído a ela no arquivo “user.c” para ser utilizado dentro da interrupção.
A Figura 14 mostra como é gerado o tempo de integração. Este trecho é inserido dentro
do código da interrupção.
extern int valorTempoInt
int dividendo=0;
int passo;
divindendo=(valorTempoInt)/50;
for(passo=0;passo<dividendo;passo++)
Delay10TCYx(60);
Figura 14: Trecho do código-fonte que gera o tempo de integração
O laço que executa a função do compilador de delay e verifica se o tempo de
integração atingiu o valor desejado é localizado entre os comandos P1_Off() e P2_Off().
O ideal seria que somente a função delay estivesse entre os dois comandos. Porém,
como desejamos implementar uma faixa de valores, isso não foi possível.
Assim, espera-se uma distorção no valor gerado dentro do circuito devido ao
tempo de execução dos comandos de verificação e incremento do passo. Quanto maior o
valor definido no arquivo-texto, maior será a quantidade de repetições destes comandos
e, portanto, maior o erro associado a ele.
19
Capítulo 4
Resultados
Neste capítulo, serão apresentados os resultados dos testes feitos em laboratório.
Mostraremos os valores do tempo de integração no sistema antigo e no atual.
Desejamos verificar que o intervalo entre os sinais de controle que fazem a amostragem
do fotodiodo (P1 e P2) no sistema antigo é de 800 µs e que no sistema atual este
intervalo de tempo assume os valores lidos do arquivo-texto “tempoIntegracao.txt”.
Para isso, foi utilizado um osciloscópio que nos mostra as tensões nos pinos do circuito
integrado que implementa estes sinais ao longo do tempo.
4.1 – O Sistema Anterior
Em primeiro lugar, para realizarmos os testes necessários, foi preciso descobrir
as configurações que foram estabelecidas para relacionar os pinos do PIC aos sinais
gerados no circuito de controle. Esta relação é definida em um dos arquivos escritos no
firmware do microcontrolador.
No projeto que já existia, o arquivo “HardwareProfile – PICDEM FSUSB.h”
contém as definições das portas do PIC e os sinais atribuídos a elas. A Figura 15 mostra
o trecho do código-fonte do arquivo em que P1 e P2 são configurados.
#define RESET1 PORTDbits.RD7 // Reset na saída D7.
#define P1 PORTDbits.RD6 // P1 na saída D6.
#define P2 PORTDbits.RD5 // P2 na saída D5.
#define Switch1 PORTDbits.RD2 // S1 na saída D2.
#define Switch2 PORTDbits.RD3 // S2 na saída D3.
#define Switch3 PORTDbits.RD4 // S3 na saída D4.
Figura 15: Trecho do código-fonte em que P1 e P2 são configurados
Pela figura, podemos concluir que os sinais de controle que fazem a amostragem
do fotodiodo devem ser observados nas portas RD6 e RD5, respectivamente. Para
descobrir quais pinos representam estas portas, consultamos o datasheet do PIC
20
18LF4550. A Figura 16 mostra a pinagem do chip do microcontrolador. Nela
verificamos que os pinos 29 e 28 representam, respectivamente, P1 e P2.
Figura 16: Pinagem do PIC 18LF4550
Desejamos verificar com o osciloscópio o comportamento dos sinais P1 e P2 ao
longo do tempo. Para isso, na interface gráfica de usuário, selecionamos o modo
“Viewfinder”. Isso faz com que estes sinais sejam gerados repetidamente e possam ser
observados através do equipamento de medidas nos respectivos pinos do PIC.
Esperamos encontrar algo semelhante ao que foi descrito na Seção 2.2, onde são
detalhados os sinais de controle do fotodiodo. A Figura 17 mostra a imagem dos sinais
de controle no tempo, obtida com o osciloscópio para o sistema antigo, onde o valor do
tempo de integração é fixo e equivale a 800 µs.
Figura 17: Tempo de integração é de 800 µs
21
Podemos notar que o valor medido é precisamente o que é esperado. Isto ocorre
porque somente os comandos da função do compilador de delay são executados entre
P1_Off() e P2_Off(), como podemos observar na Figura 18.
P1_Off();
Delay10TCYx(120);//100us
Delay10TCYx(120);//100us
Delay10TCYx(120);//100us
Delay10TCYx(120);//100us
Delay10TCYx(120);//100us
Delay10TCYx(120);//100us
Delay10TCYx(120);//100us
Delay10TCYx(120);//100us
P2_Off();
Figura 18: Trecho do código-fonte onde é gerado o tempo de integração de 800 µs
A função é chamada oito vezes seguidas, gerando um atraso de 100 µs a cada
execução. O tempo desejado foi gerado desta forma por escolha do autor do projeto
anterior [1]. Além desta solução, poderia ter sido usado o temporizador do
microcontrolador para gerar este atraso. Outra forma seria usar a própria função do
compilador de delay, chamada apenas uma vez, com o valor do argumento passado a ela
gerando o tempo desejado. Neste momento, as fontes de erro associadas a cada uma
destas soluções alternativas não são bem conhecidas no nosso laboratório. Neste
trabalho não serão analisadas estas possíveis soluções.
4.2 – O Novo Sistema
Com o projeto já modificado, desejamos verificar se o tempo de integração,
intervalo entre os sinais de controle que fazem a amostragem do fotodiodo P1 e P2,
estão assumindo os valores que são definidos no arquivo-texto.
Para isso, o procedimento realizado é o mesmo descrito na Seção 4.1 com a
diferença que aqui criamos o arquivo “tempoIntegração.txt” e escrevemos nele o valor
que desejamos observar. Nas Figuras 19 a 25 temos imagens capturadas com o
osciloscópio para os seguintes valores de tempo de integração: 100 µs, 500 µs, 800 µs,
1200 µs, 1800 µs, 2500 µs e 3000 µs respectivamente.
22
Figura 19: Tempo de Integração é de 126 µs
Figura 20: Tempo de integração é de 544 µs
Figura 21: Tempo de integração é de 860 µs
23
Figura 22: Tempo de integração é de 1280 µs
Figura 23: Tempo de integração é de 1910 µs
Figura 24: Tempo de integração é de 2640 µs
24
Figura 25: Tempo de integração é de 3160 µs
Podemos perceber uma discrepância entre os valores medidos e os definidos no
arquivo-texto. Esta diferença era esperada devido ao tempo de execução do laço de
repetição que gera o tempo de integração (soluções alternativas, como as mencionadas
no final da Seção 4.1, não foram investigadas). Quanto maior o valor do tempo de
integração maior será a diferença absoluta encontrada. Isto ocorre devido à verificação e
ao incremento do passo que acontece mais vezes para valores maiores.
Notamos também que já para o valor de 800 µs o erro no valor supera o tamanho
do passo. Para o valor limite de 3000 µs a diferença é de mais de cinco por cento ou três
vezes o passo de 50 µs. Isto não é desejado e torna o sistema pouco confiável.
Para reduzir o efeito percebido nos exemplos acima, devemos aumentar o
tamanho do passo, ou seja, o valor do atraso gerado em cada execução da função delay.
Porém, ao fazermos isso diminuímos a quantidade de valores que podem ser definidos
no arquivo-texto e implementados no sistema de controle do sensor CMOS.
4.3 – Aumentando o Tamanho do Passo
Pelos motivos expostos na Seção 4.2 decidimos aumentar o tamanho do passo de
50 µs para 100 µs e realizar as mesmas metidas feitas anteriormente. Essa escolha foi
puramente intuitiva e levou em consideração apenas os valores que podem ser gerados
através deste passo. Nas Figuras 26 a 32 podemos observar os resultados medidos para
os valores definidos no arquivo “tempoIntegração.txt” de: 100 µs, 300 µs, 500 µs, 800
µs, 1200 µs, 1800 µs, 2500 µs e 3000 µs respectivamente.
25
Figura 26: Tempo de integração é de 106 µs
Figura 27: Tempo de integração é de 512 µs
Figura 28: Tempo de integração é de 820 µs
26
Figura 29: Tempo de integração é de 1230 µs
Figura 30: Tempo de integração é de 1840 µs
Figura 31: Tempo de integração é de 2560 µs
27
Figura 32: Tempo de integração é de 3060 µs
Perceba como o erro encontrado diminui significativamente. Agora, para toda a
faixa de valores possíveis, a diferença entre os valores definidos no arquivo-texto e os
valores medidos é sempre menor que o tamanho do novo passo. Para o maior valor
implementado, que é de 3000 µs, o acréscimo é de apenas dois por cento em relação ao
valor esperado.
É possível que exista um valor ótimo para o tamanho do passo e um método para
se chegar a este valor. Porém, devido ao limite de tempo para a conclusão, este trabalho
limitou-se à implementação da forma aqui apresentada.
Outra forma de variar o valor do tempo de integração, dentro da faixa desejada,
também poderia ser pensada, de maneira a eliminar o uso do laço de repetição e
consequentemente o erro associado a ele. Minha sugestão seria usar a própria função do
compilador de delay recebendo como entrada o valor necessário para gerar o intervalo
de tempo desejado. Embora a função Delay10TCYx() aparente possuir um limite para o
valor do argumento passado a ela, existe a função Delay100TCYx() para implementar
esses intervalos maiores, mas também com outros erros possíveis. O estudo desta
solução poderá ser feito em investigações posteriores à conclusão deste trabalho.
28
Capítulo 5
Conclusões
Ao final deste trabalho podemos concluir que o projeto atingiu o principal
objetivo proposto, como pôde ser visto no Capítulo 4. O sistema agora funciona com o
tempo de integração para o fotodiodo, intervalo entre os sinais P1 e P2, assumindo o
valor estabelecido no arquivo-texto “tempoIntegracao.txt”.
Ao longo do projeto, como já foi dito, a maior dificuldade encontrada talvez
tenha sido o entendimento do sistema que já existia e que foi base para este novo
projeto. Esta etapa foi a que consumiu o maior tempo deste trabalho.
A solução encontrada foi simples e coerente com o sistema existente. Sua
implementação em si foi bastante rápida, com uma ou outra tentativa frustrada. Houve
alguma dificuldade para adequar o sistema físico e realizar os testes no laboratório,
devido à falta de familiaridade com o circuito e os programas utilizados no projeto
anterior. Isso demandou um certo tempo de aprendizado no laboratório e resultou em
algumas tentativas mal sucedidas.
Também durante a validação do método percebemos, através dos resultados
medidos, que a especificação inicial para a variação dos valores possíveis para o tempo
de integração não gerou resultados satisfatórios. O passo inicial de 50 µs resultou em
erros muito grandes para os valores medidos. Assim, adotamos um passo de 100 µs que
apesar de diminuir a quantidade de valores possíveis tornou o erro bem menor.
Seria interessante, como sugestão para um trabalho futuro, o desenvolvimento
de um sistema que gere automaticamente o tempo de integração ideal para fotodiodo e o
escreva no arquivo-texto. Este valor seria baseado nas condições de iluminação e
contraste da imagem a ser capturada pelo sensor de imagens CMOS.
Além disso, outra sugestão seria diminuir o erro encontrado, durante as medidas
realizadas, nos valores gerados para o tempo de integração. Para isso, seria necessário a
implementação de um método que elimine o laço de repetição para produzir o intervalo
de tempo desejado, como é o caso das soluções sugeridas no final da Seção 4.3.
29
Bibliografia
[1] F. D. V. R. de Oliveira, Circuito Integrado para Compressão de Imagens no Plano
Focal utilizando Quantização Vetorial e DPCM, Projeto Final de Graduação,
DEL/EPOLI/UFRJ, janeiro de 2012.
[2] Hugo L. Haas, Projeto de Circuitos para Compressão de Imagens no Plano Focal
de Câmeras CMOS, Dissertação de Mestrado, DEL/EPOLI/UFRJ, janeiro de 2012.
[3] G. D. Boreman, Modulation Transfer Function in Optical and Eletro-Optical
Systems, 1st ed. Bellingham, Washington: SPIE, 2001.
[4] Leando d’Oliveira do Rêgo, Configuração de um Sensor de Imagens CMOS com
Compressão de Imagens no Plano Focal para Operação em Modo de Vídeo, Projeto
Final de Graduação, DEL/EPOLI/UFRJ, abril de 2013.
[5] Julio Preuss, Qual a diferença entre CCD e CMOS? Disponível em
http://www.techtudo.com.br/platb/fotografia/2011/03/21/qual-a-diferenca-entre-ccd-e-
cmos/ Acesso em 11 de agosto de 2015.
[6] https://www.microchip.com/
[7] http://www.cplusplus.com/
