Post on 08-Feb-2019
UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁOFICINAS DE INTEGRAÇÃO 2
BRUNO DE F. OENNING, CARLOS EDUARDO L. DE S. GRELL SILVA,FELIPE LISBOA
LEDPAD: UTILIZANDO LED’S COMO SENSORES
RELATÓRIO FINAL
CURITIBA
2013
BRUNO DE F. OENNING, CARLOS EDUARDO L. DE S. GRELL SILVA,FELIPE LISBOA
LEDPAD: UTILIZANDO LED’S COMO SENSORES
Relatório Final apresentado à disciplina de Oficinasde Integração 2 da Universidade TecnológicaFederal do Paraná como requisito parcial para aaprovação
Orientador: Juliano Mourão Vieira
CURITIBA
2013
RESUMO
OENNING, Bruno; GRELL, Carlos; LISBOA, Felipe. LEDPAD: UTILIZANDO LED’SCOMO SENSORES. 25 f. Relatório Final – Oficinas de Integração 2, Universidade TecnológicaFederal do Paraná. Curitiba, 2013.
Este trabalho descreve a utilização de diodos emissores de luz (LEDs) como emissores esensores de luz para a implementação de um touchpad. Basicamente utiliza-se uma matrizde LEDs para fazer a emissão e o sensoriamento de luz; uma plataforma de hardware (Arduino)é usada para fazer a leitura dos sensores, e um programa de computador é empregado parao processamento e movimentação do ponteiro do mouse na tela. Ao usuário aplicar umamovimentação sobre a matriz de LEDs, o programa responde com uma movimentação do mousena tela.
Palavras-chave: LEDpad, Sensor de LED, LED Touch
LISTA DE FIGURAS
–FIGURA 1 Diagrama de Blocos do Sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9–FIGURA 2 Camadas especializadas do software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14–FIGURA 3 Cálculo da Coordenada Cartesiana . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15–FIGURA 4 Modelo da matriz utilizada no projeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16–FIGURA 5 Sentido da varredura para criação da matriz . . . . . . . . . . . . . . . . . . . . . . . . . . . 16–FIGURA 6 Matriz adaptada ao multitoque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
LISTA DE TABELAS
–TABELA 1 Cronograma. Autor: Autoria Própria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20–TABELA 2 Tabela do Orçamento. Autor: Autoria Própria . . . . . . . . . . . . . . . . . . . . . . . . . . 21
SUMÁRIO
1 CAPÍTULO 1 - A PROPOSTA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.1 INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.2 MOTIVAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.3 OBJETIVO GERAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.4 OBJETIVOS ESPECÍFICOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102 CAPÍTULO 2 - FUNDAMENTAÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.1 ARDUINO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112.2 PROPRIEDADES DO LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 CAPÍTULO 3 - DESENVOLVIMENTO DO PROJETO . . . . . . . . . . . . . . . . . . . . . . . . 123.1 ETAPAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123.2 TESTE SINGULAR DO LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123.3 * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 13
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 13
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 13
3.4 COMUNICAÇÃO ENTRE ARDUINO E PROGRAMA DE COMPUTADOR . . . . . . 133.5 IMPLEMENTAÇÃO DO CONTROLE DO PONTEIRO DO MOUSE DO
COMPUTADOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14Comunicação Serial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 14
Interpretação dos Dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 14
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 14
Ajuste dos dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 15
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 15
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 15
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 16
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 16
Movimentação do ponteiro do mouse . . . . . . . . . . . . . . . . . . . . . . p. 17
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 17
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 17
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . p. 18
4 CAPÍTULO 4 - CONCLUSÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194.1 RESULTADOS E DISCUSSÕES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 CAPÍTULO 5 - APÊNDICES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 CAPÍTULO 6 - CÓDIGO DO ARDUINO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22REFERÊNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
9
1 CAPÍTULO 1 - A PROPOSTA
1.1 INTRODUÇÃO
O projeto consiste na criação de um mouse para computador utilizando as propriedades
do LED de forma alternada como emissor e sensor de luz. A abordagem da proposta foi dividida
basicamente em três partes: detecção da interação com o usuário, comunicação e processamento
dos dados. A parte de detecção utiliza um conjunto de LEDs como emissores e sensores
de luz, sendo controlados por um Arduino o qual é responsável também pela leitura e pré-
processamento dos dados. Na etapa da comunicação, o Arduino envia os dados pré-processados
para um programa de computador através de uma entrada USB. A etapa final de processamento
do programa trata os dados recebidos e responde com uma movimentação do mouse na tela. Os
detalhes descritos entre essas etapas podem ser observadas na figura 1.
Figura 1: Diagrama de Blocos do Sistema
1.2 MOTIVAÇÃO
O interesse no manuseio de hardware na composição de um dispositivo de interação
direta com o computador sempre foi algo que despertou interesse acadêmico na equipe,
entretanto a complexidade e a necessidade de múltiplas competências sempre surge como uma
barreira para projetos mais "ousados". A inserção de plataformas abertas para a iniciação do
10
estudo da eletrônica embarcada possibilitou a redução do universo de domínio do conteúdo,
melhorando a afinidade e motivação dos alunos para o desenvolvimento desses projetos,
aproximando a universidade com o mercado, e que, resumindo em uma frase, desperta o espírito
de querer “fazer um projeto interessante funcionar”.
1.3 OBJETIVO GERAL
• Criação de um touchpad utilizando LEDs.
1.4 OBJETIVOS ESPECÍFICOS
• Estudo das propriedades do LED como sensor de luminosidade.
• Uso da matriz de LEDs com o Arduino.
• Desenvolvimento do software base para a detecção das da matriz pelo Arduino.
• Criação de um modelo de comunicação para tráfego dos dados obtidos para o computador.
• Recepção dos dados pré-processados do arduino para um software de alto nível, para a
realização da interação do ponteiro do mouse do computador.
11
2 CAPÍTULO 2 - FUNDAMENTAÇÃO
2.1 ARDUINO
A programação na plataforma Arduino é baseada na linguagem Processing, com
elementos semelhantes à linguagem C/C++, e mais alguns comandos para controle dos
terminais (conexão de hardware). Entre esses comandos, estão o DigitalWrite, DigitalRead
e PinMode. O comando DigitalWrite determina o nível lógico de um terminal, já o
DigitalRead é responsável por fazer a leitura desse nível lógico. O PinMode tem como objetivo
basicamente declarar um terminal como entrada ou saída. O modo de entrada basicamente
é utilizado para fazer leituras e o de saída para fornecer níveis lógicos a componentes.
Existem comandos similares via registradores de porta que permitem uma maniputação de
baixo nível e mais rápida dos terminais de entrada e saída. Entre eles estão DDR(PORTA),
PORT(PORTA) e PINT(PORTA), onde PORTA representa a porta que está sendo utilizada,
podendo ser encontrada no PinMapping do Arduino. O DDR(PORTA) é análogo ao PinMode, o
PORT(PORTA) é análogo ao DigitalWrite e o PIN(PORTA) é similar ao DigitalRead. (BANZI,
2009; DEKKER MARIE BODEN, 2012)
2.2 PROPRIEDADES DO LED
O LED, em seu funcionamento normal (polarizado diretamente), emite luz. Já quando
polarizado inversamente, se comporta como um sensor de luminosidade. Essa característica de
sensor é dada pela propriedade capacitiva do LED, de forma que a luz ambiente influencia no
tempo de descarga. Esse tempo de descarga é menor quanto maior for a incidência de luz, ou
seja, em ambientes melhor iluminados, o cátodo do LED possui maior velocidade de descarga,
quando comparada a ambientes com menor incidência de luz. Portanto, o tempo de descarga do
LED é inversamente proporcional a iluminação, ou seja, quanto maior a iluminação, menor vai
ser o tempo de descarga. (HUDSON, 2004; DIETZM WILLIAM YERAZUNIS, 2003)
12
3 CAPÍTULO 3 - DESENVOLVIMENTO DO PROJETO
3.1 ETAPAS
O desenvolvimento do projeto foi composto pelas seguintes etapas: teste singular do
LED como sensor, teste da matriz de LED, comunicação Arduino-programa de computador e
implementação do programa para controle do mouse.
3.2 TESTE SINGULAR DO LED
O teste singular do LED teve como objetivo fazer os primeiros testes das propriedades
de polarização direta e inversa do LED. Para tal, foi utilizado um Arduino Duemilanove e um
LED. Polarizou-se o LED inversamente, ou seja, nível lógico 1 no cátodo e nível lógico 0 no
ânodo. Foram feitas então diversas leituras no cátodo a respeito do tempo que demorava para
ele chegar ao nível lógico 0. Após esses testes, comprovou-se que a propriedade capacitiva do
LED quando polarizado inversamente era válida, ou seja, o tempo de possui uma relação não
linear com a iluminação incidente.
3.3 *
Teste da Matriz de LED
Os testes da matriz de LED tiveram como objetivo utilizar um conjunto de LED para
atuarem como sensores e emissores de luz. Para isso, o Arduino Duemilanove teve de ser
trocado pelo Arduino Mega, pois o primeiro não possuía os 12 ‘terminais’ digitais suficientes
para a conexão com a matriz de LEDs. A matriz de LEDs utilizada possui catódos comuns
e ânodos comuns, e como a leitura do tempo para chegar ao nível lógico 0 é feita no cátodo,
começaram a surgir problemas de interferência na leitura de um LED, pois os outros LEDs
comuns ao mesmo cátodo afetavam seu tempo de descarga (quando o cátodo começava a se
descarregar, sua tensão ficava menor do que a dos ânodos que não estavam sendo lidos e os
13
LEDs ficavam polarizados diretamente, havendo passagem de corrente para o cátodo). Para
resolver esse problema, primeiramente foram colocados os terminais dos ânodos dos LEDs que
não estavam sendo lidos naquele momento no modo de entrada no Arduino, com a intenção de
gerar uma alta impedância.
Como a solução foi insuficiente, houve a ideia de desconectar resistores internos de pull-
up nos terminais dos ânodos que não estavam sido lidos naquele momento, a fim de forçar
uma alta impedância em tais terminais. Registradores de porta foram utilizados não só para
manipular os pull-ups, mas também para definir terminais como entrada e saída, fazer leituras e
também definir o nível lógico de cada um. Essa alteração melhorou muito o tempo de resposta,
e ao mesmo tempo resolveu o problema do cátodo comum. Portanto no código atual, ocorre
uma varredura na matriz de LEDs, cada LED é polarizado inversamente, é gerada uma alta
impedância na porta dos ânodos dos LEDs que não estão sendo lidos, e uma váriavel auxiliar é
utilizada para a medição do tempo que o cátodo demora para chegar ao nível Lógico 0.
Além do problema no cátodo, encontrou-se o problema da variação do tempo de descarga
com a mudança de ambiente, ou seja, o tempo de descarga no cátodo do LED depende da
iluminação local, não se conseguindo ajustar um tempo de descarga padrão. Para resolver este
problema, foram instalados LEDs de apoio em torno da matriz de LEDs, criando uma espécie
de “backlight”, melhorando o desempenho. Primeiramente, para calibrar o tempo de descarga
do LED, foi utilizada a reflexão da luz do LED nos dedos, o que deixava a descarga mais rápida.
Mas devido à iluminação externa, ao invés de acelerar o tempo de descarga, a interrupção do
LED passou a atuar como uma barreira para entrada de luz, deixando a descarga mais lenta.
Além disso, houve uma melhor amplitude na variação do tempo do LED quando essse está
iluminado ou interrompido, diminuindo o sensoriamento de ruídos.
O código fonte final utilizado no Arduino está em anexo nos apêndices finais.
3.4 COMUNICAÇÃO ENTRE ARDUINO E PROGRAMA DE COMPUTADOR
Através da biblioteca rxtx (http://rxtx.qbang.org/wiki/index.php/MainPage), é possível
trabalhar com o protocolo de comunicação serial, tanto para envio quanto para recepção de
dados. O uso dela basicamente é destinado à detecção da porta e a criação do canal para a
recepção dos dados. A referência da biblioteca apresenta um modelo de código. O código
foi utilizado como base, sendo adicionadas novas funcionalidades para o melhor contexto do
14
projeto. Foi inserida uma estrutura para a detecção automática da porta serial (no caso, USB),
tratamento de erros, possibilitando desconectar e reconectar a placa em outra porta disponível,
evitando dessa forma erros em tempo de execução. Dados recebidos de forma incorreta são
descartados, evitando inconsistências.
3.5 IMPLEMENTAÇÃO DO CONTROLE DO PONTEIRO DO MOUSE DOCOMPUTADOR
O software basicamente é dividido entre os seguintes módulos:
Figura 2: Camadas especializadas do software
Comunicação Serial Módulo responsável por fazer a detecção das portas disponíveis e criar
o canal de comunicação com o Arduino. A classe responsável simplesmente lista as portas e
faz uma varredura até encontrar a porta com o Arduino. Em resumo, é o uso da biblioteca
rxtx (modelo disponível na documentação do rxtx). De acordo com a figura 2, essa camada
fundamenta o software, criando o interfaceamento com o Arduino.
Interpretação dos Dados Módulo responsável por fazer a seleção dos dados relevantes,
evitando assim a geração de erros devido a falhas de comunicação.
O funcionamento da estrutura basicamente fará a leitura de uma matriz, checando o
comprimento dos dados e verificando se há alguma inconsistência. Caso haja algum dado
15
inválido, ele simplesmente será descartado. O mecanismo de controle adotado foi uma
verificação padrão de dados. A camada de comunicação recebe os dados em forma de texto
(String), tendo um valor fixo e contendo apenas valores numéricos. Caso os dados recebidos
não estejam nesse formato, eles são desconsiderados.
Ajuste dos dados Camada destinada a realizar a interpretação lógica, com a finalidade de
detectar a movimentação do touchpad. Essa estrutura faz a leitura dos dados recebidos (uma
String contendo zeros e uns), e de acordo com a matriz a ser utilizada, fará a conversão para o
seu mapeamento.
Figura 3: Cálculo da Coordenada Cartesiana
A técnica utilizada para gerar o vetor leva em consideração somente a interrupção localizada
no nível mais alto da matriz, tratando assim o problema do cátodo comum (no qual o ponto
mais elevado falsamente gera uma interrupção nos elementos abaixo dele. Após essa filtragem,
é realizada uma média ponderada, levando em consideração a posição da interrupção e o peso
da sua coordenada cartesiana. A média é realizada em ambos os eixos para a criação do vetor.
O vetor gerado é adicionado em uma fila para a criação do movimento do ponteiro pela
camada acima do software. A implementação da fila possibilita a ordenação e o tratamento
sequencial dos vetores.
16
Figura 4: Modelo da matriz utilizada no projeto
Através de uma matriz passada pelo Arduino, por meio de uma média ponderada, é criado
um vetor (x, y) representando o local onde a matriz mais sofre influência. Fazendo uma análise
com a matriz anterior, é possível definir o deslocamento desse vetor, assim tendo um parâmetro
para a movimentação do ponteiro do mouse.
Figura 5: Sentido da varredura para criação da matriz
A figura acima demonstra o sentido no qual o Arduino efetua a varredura na matriz (esse
sentido arbitrário foi definido na implementação da leitura
17
Movimentação do ponteiro do mouse Camada destinada a receber os dados de
movimentação e criar um resultado mais apropriado, dando mais naturalidade para o
movimento, de acordo com a resposta do usuário, tendo assim um controle de aceleração e
velocidade para o ponteiro do mouse. A análise simples quadro a quadro repassada pela camada
inferior não resultará em uma movimentação adequada, sendo necessária a existência de um
buffer para adicionar uma certa “inteligência” no software, interpolando as alterações bruscas
e parametrizando o movimento em função da aceleração e velocidade, proporcionando uma
maior naturalidade. Essa implementação permite a detecção de movimentos singulares (técnica
semelhante aos touchpads da geração anterior).
A movimentação do ponteiro do mouse utiliza uma biblioteca
de objetos da própria API do java, a biblioteca awt.Robot
(http://docs.oracle.com/javase/1.4.2/docs/api/java/awt/Robot.html).
Para a movimentação simples do ponteiro, o código necessário é bem reduzido e
demonstrado abaixo:
// Move o cursor
Robot robot = new Robot();
robot.mouseMove(xCoord, yCoord);
while(true){
try {
Thread.sleep(500);
xCoord+= 5;
yCoord+= 5;
robot.mouseMove(xCoord, yCoord);
} catch(InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
A movimentação adotada no trabalho não possui a implementação do buffer para dar mais
naturalidade ao movimento, porém, pode ser acrescida a funcionalidade utilizando um timer
com tempo fixo e uma fila contendo mais de dois vetores (método que pondera múltiplos
vetores, podendo detectar a velocidade e aceleração no deslocamento na matriz).
18
Para uma implementação multitoque, foi definida uma abordagem de segmentar a matriz
em setores, cada um se comportando como se fosse uma matriz individual.
Figura 6: Matriz adaptada ao multitoque
19
4 CAPÍTULO 4 - CONCLUSÃO
4.1 RESULTADOS E DISCUSSÕES
A proposta da criação do LEDpad foi concretizada de acordo com o que havia sido
citado. A problemática do uso da matriz com cátodos e ânodos comuns apresentou uma certa
dificuldade devido à presença de interferências entre as leituras de cada LED individualmente.
Uma das questões que não havia sido muito focada, a da movimentação do cursor, gerou
uma série de formulações, sendo a mais básica a adotada. Entretanto, o código permite uma
implementação para a criação de uma interface multitoque, simplesmente segmentando a matriz
em setores e realizando os devidos tratamentos. Como ideia para trabalhos futuros nessa
área, sugere-se a expansão do software em um sistema mais robusto, que possibilite maior
customização por parte do usuário e melhor precisão.
20
5 CAPÍTULO 5 - APÊNDICES
Tarefas Início Duração (dias)LED como sensor 26/06/2013 14Controle da Matriz de LEDs utilizando Arduino 16/07/2013 5Leitura da Matriz de LED’s utilizando Arduino 23/07/2013 20Comunicação Arduino-Computador 20/08/2013 5Programa Computador para controle do mouse 27/08/2013 17
Tabela 1: Cronograma. Autor: Autoria Própria
21
Componente Preço unitário (reais) Quantidade Total (reais)Arduino Mega 89,00 1 89,00Matriz de LEDs 10,00 1 10,00LED de Alto Brilho 0,60 10 6,00
Tabela 2: Tabela do Orçamento. Autor: Autoria Própria
22
6 CAPÍTULO 6 - CÓDIGO DO ARDUINO
// LED sensor -- photodiode.
// Bruno de Freitas Oenning
// Carlos Eduardo
// Felipe Lisboa
int numCatodos=3;
int numAnodos=5;
int tempoDescarregamento;
//cada LED possui um tempo de descarga particular
int tempoDescargaNormal[3][5]={2620, 2600,2500,2200,2600,
4600,4500,4100,4200,3500,
2800,3300,4700,2700,3000};
int i,count,k,j;
int catodos[]={PC3,PC2,PC4};
int catodosPinos[]={34,35,33};
int anodos[]={PA5,PA6,PA4,PA3,PA2};
int anodosPinos[]={27,28,26,25,24};
String acionados="";
//Pinos A contém os anodos
//Pinos C contém os catodos
void setup()
{
DDRA = 0b11111111;//set todas as portas A como saida (output)
DDRC= 0b11111111;// set todas as portas C como saída
Serial.begin(115200);//Taxa de transmissão serial
}
void loop()
23
{
acionados=""; // Zera os acionados
for(j=0;j<numAnodos;j++)//Fo para fazer a medição em todos os catodos
{
for(i=0;i<numCatodos;i++)//For para fazer a medição em todos os catodos
{
_SFR_IO8(0x35) |= 0x10;
//Liga a Matriz
PORTA = 0b01111111;
PORTC = 0b00000000;
delay(0.9999999998);
tempoDescarregamento=0;
//necessário para os leds que não estam sendo lidos não influenciarem na leitura do LED atual
for(k=0;k<numAnodos;k++)
{
if(k!=j)
{
DDRA= (0 << (anodos[k]));
_SFR_IO8(anodos[k]) |= (1<<(anodos[k]));
}
}
for(k=0;k<numCatodos;k++)
{
if(k!=i)
{
PORTC = (1 << (catodos[k]));
_SFR_IO8((catodos[k])) |= (1<<(catodos[k]));
}x’’
}
//inverter a polaridade do anodo com o catodo
PORTA = (0 << (anodos[j]));
PORTC = (1 << (catodos[i]));
24
//Abrir a porta para leitura
DDRC = (0 << (catodos[i]));
while((PINC& (1 << (catodos[i])))!=0)
{
tempoDescarregamento++;
}
if(tempoDescarregamento>tempoDescargaNormal[i][j] )
{
acionados+=’1’;
}
else
{
acionados+=’0’;
}
DDRA = 0b11111111;//set todas as portas A como saida (output)
DDRC = 0b11111111;// set todas as portas C como saida
}
}
Serial.println(acionados);//Manda para o programa os leds Acionados
}
25
REFERÊNCIAS
BANZI, M. Getting Started With Arduino. Sebastopol, CA, USA, 2009.
DEKKER MARIE BODEN, M. L. A. Working With Arduino. University Of Queensland, AU,2012.
DIETZM WILLIAM YERAZUNIS, D. L. P. Very Low-Cost Sensing and CommunicationUsing Bidirectional LEDs. Cambridge, MA, 2003.
HUDSON, S. Using Light Emitting Diode Arrays as Touch-Sensitive Input and Output Devices.Santa Fe, New Mexico, USA, p. 1–4, 2004.