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.