Loading presentation...

Present Remotely

Send the link below via email or IM

Copy

Present to your audience

Start remote presentation

  • Invited audience members will follow you as you navigate and present
  • People invited to a presentation do not need a Prezi account
  • This link expires 10 minutes after you close the presentation
  • A maximum of 30 users can follow your presentation
  • Learn more about this feature in our knowledge base article

Do you really want to delete this prezi?

Neither you, nor the coeditors you shared it with will be able to recover it again.

DeleteCancel

Make your likes visible on Facebook?

Connect your Facebook account to Prezi and let your likes appear on your timeline.
You can change this under Settings & Account at any time.

No, thanks

Sensores e Actuadores

No description
by

José Coelho

on 9 July 2014

Comments (0)

Please log in to add your comment.

Report abuse

Transcript of Sensores e Actuadores

Sensores e Actuadores
José Coelho
Silves, Retiro DMAD 2014
Fundamentos de Sensores e Actuadores
Actuador: reage a uma diferença de potencial
Sensor: gera uma diferença de potencial
Montagem: ligação entre os diversos componentes
Hardware
Arduíno UNO;
1 cabo USB (tipo impressora, para ligar o Arduíno ao PC);
1 breadboard;
5 metros de fio condutor fino;
4 LEDs;
1 LED bi-color (ou tri-color);
2 potenciómetros;
2 interruptores;
4 botões de pressão;
1 sensor piezoelectrico;
10 ou 20 resistências de 220 Ohms
10 resistências de 10K Ohms
1 integrado 74LS00;
1 integrado 74LS04;
2 display de 7 segmentos;
2 integrados com registo de 8 bits, entrada em série e saída em paralelo, ou conversor BDC...;
...

Ferramentas:

alicate descarnador (ou alicate de corte/universal + canivete);
caixa de arrumação (muitos espaços pequenos, e espaço para a breadboard);
ferro de soldar (para quem queira experimentar).
Fritzing
http://fritzing.org/home/
Programa para desenhar esquemas:
Permite especificar todas as ligações;
Utilizar antes e/ou após a montagem;
Destina-se também ao próprio autor.
Como utilizar uma Breadboard?
Permite fazer ligações entre componentes, sem necessidade de se soldar;
Pinos ligados horizontalmente, e verticalmente;
Podem-se acoplar várias breadboards;
Fazer ligações na horizontal/vertical, nunca em diagonal;
Utilização de multímetro, para confirmar ligações entre pinos.
Como ligar um LED?
ânodo (perna mais longa) à alimentação
cátodo (perna mais curta) à terra
série com resistência de 220 Ohms
Com multímetro é possível verificar o valor das resistências
Importante que o primeiro LED ligado utilize uma fonte de alimentação por pilhas, não utilizar o Arduino
Como utilizar um potenciómetro?
Resistência variável;
Pins externos, ligar à alimentação / terra;
Pin central, ligar ao valor da resistência variável, e portanto, tensão variável, já que a alimentação tem tensão constante.
Atenção: se o potenciómetro no mínimo tiver resistência nula, colocar uma resistência em série com o LED
Como utilizar um interruptor?
Igual ao potenciómetro;
Apenas duas posições, fechado de um lado, ou do outro.
Como utilizar um circuito integrado?
Um CI pode conter uma funcionalidade pretendida
Não trocar:
orientação e alimentação do CI;
um pin de entrada por um de saída e vice-versa.
Ver bem o esquema (data sheet), e desenhar com cuidado o que se pretende no Fritzing, antes de montar
Como utilizar um botão de pressão?
ligar com resistência elevada (10K Ohms), o pin de descanço, ao valor pretendido (alimentação/terra);
A situação de alta impedância, é distinto de uma ligação à terra.
Montar um cicuito que tenha:

Três LEDs (RGB), que acendem quando se carrega num botão de pressão;
Um display de 7 segmentos continuadamente ligados (cada segmento é um LED separado);
Um potenciómetro a controlar a luminosidade de LED;
Um interruptor a controlar a cor de um LED bi-color, que acende se o botão de pressão estiver em baixo;
Utilização de outro qualquer sensor/actuador.
Trabalho
Introdução à
plataforma Arduino

Objectivos: utilização dos pinos do Arduino de saída/entrada, tanto digitais como analógicos, de modo a controlar sensores e actuadores digitais e analógicos.
Arduino UNO, o que é?
Como ligar LEDs ao arduino?
Como ler informação de um interruptor?
Como ler informação de um botão?
Como ler informação analógica, de um potenciómetro?
Como gerar output analógico?
Como controlar um actuador piezoeléctrico?
Como ler informação do sensor piezoeléctrico?
Como utilizar um display de 7 segmentos?
Como utilizar um registo, para poupar o número de pins do Arduíno?
Como estabilizar um sinal analógico instável?
Como gravar e reproduzir um sinal ao longo do tempo?
Versão A - Montar um circuito que utilize o Arduíno, em que:

Existe um botão de pressão, que enquanto está pressionado vão passando números de 1 a 6 num display de 7 segmentos;
Quando o botão e libertado, o número existente no momento pára, e é produzido sequencialmente através de um LED, que pisca tantas vezes quantas o número gerado, e em simultâneo por um sensor piezoelectrico, que apita de forma sincronizada com o LED;
Caso um interruptor esteja ligado, passado algum tempo, o LED e o sensor piezoelectrico, reproduzem o número novamente;
Um potenciómetro controla o tempo que leva a passar de um número para o seguinte, sendo lento (cerca de um segundo), num dos extremos, e muito rápido (milisegundos ou zero), no outro extremo (após o tempo de espera entre números ficar a baixo do tempo de reacção da pessoa, o número gerado pode ser considerado aleatório);
Utilização de outro qualquer sensor/actuador, ou implementação de alguma outra funcionalidade com os sensores/actuadores
Trabalho A
Trabalho B
Versão B - Montar um circuito que utilize o Arduíno, em que:

Grave uma sequência input colocada através de um botão de pressão, como se fosse código morse (quem saber pode utilizar), e deixar um LED a repetir essa sequência, bem como sensor piezoeléctrico. Deve aguardar uns 5 segundos, e após 5 segundos de silêncio, repetir a sequência.
A identificação de ponto e traço deve ser feita considerando o tempo menor e o tempo maior, ficando como pontos todos os sinais a baixo da média dos dois extremos.
A sequência deve ser reproduzida utilizando não o tempo para cada ponto e traço, mas sim o mesmo tempo para todos os pontos (e traços), sendo esse tempo determinado pela média dos tempos utilizados na introdução da sequência (média dos pontos e média dos traços);
Caso a sequência seja de SOS (três pequenos, três grandes e três pequenos), tocar um alarme com o sensor piezoeléctrico;
Na altura do alarme, variar 8 leds em de forma diversa e imaginativa;
Fazer um cadeado de um cofre, controlado por um potenciómetro. O potenciómetro controla 2 displays de 7 segmentos, podendo ir de 00 a 99. Para inserir um determinado código o cofre, tem de ir a um número, e ao recuar o número é considerado marcado. Por exemplo, o seguinte código é válido: 10 » 75 » 34 » 89. Para desbloquear o código teria-se de começar num número a cima de 10, baixar para 10, subir para 75, baixar para 34 e subir para 89, e parar durante 5 segundos. Quando o cofre abrir, acender LEDs bi-color a verde, c.c. colocar os LEDs bi-color trocar a vermelho durante 5 segundos, apagando de seguida, sendo possível após isso tentar nova sequência.
O circuito do código morse deve poder funcionar em simultâneo com o cadeado do cofre.
Utilização de outro qualquer sensor/actuador, ou implementação de alguma outra funcionalidade com os sensores/actuadores existentes.
Utilização do Arduino e Processing
Objectivos: interligação do processing com o arduino, possibilitando o controle no processing de sensores e actuadores através do arduino.
Como ler informação do Arduino no PC?
Como ler informação dos sensores no processing?
Como controlar actuadores do processing?
Trabalho A
Versão A - Montar um circuito que utilize o Arduíno e Processing, em que:

Exista captação de vídeo no Processing, e sempre que há detecção de movimento, um conjunto de LEDs brilham, conforme a intensidade do movimento (teste colocando os LEDs em frente do vídeo);
Utilizar dois/três potenciómetros para influenciar a zona de vídeo captada no processing (X, Y, zoom (digital), do vídeo capturado). Caso tenha apenas dois potenciómetros, utilize botões de pressão para o zoom.
Passados 10 segundos sem interacção nos potenciómetros, repor a posição neutra (centro do potenciómetro), alterando para o valor dos potenciómetros assim que estes fiquem activos
Trabalho B
Versão B - Montar um circuito que utilize o Arduíno e Processing, em que:

Monte um jogo de perícia no Processing, entre dois ou mais jogadores. Cada jogador controla um movimento numa só dimensão (0 a 100%), pelo que pode jogar com um potenciómetro, ou com o rato (contando apenas a dimensão horizontal), com dois botões (esquerda/direita) ou teclado (setas esquerda/direita, e teclas AD).
Não há necessidade de configurar quantos jogadores estão presentes no jogo, assim que um potenciómetro, rato, botões ou teclado são activados, esse jogador entra no jogo.
Pode optar por fazer um jogo original, ou então fazer o seguinte jogo:
Tendo por base o artefacto das bolas, gerar uma bola maior, com o dobro do tamanho das restantes: a bola bomba.
Apenas um jogador está activo a cada momento, e controla uma barra de segurança, que se move na zona de baixo.
A bola bomba não pode tocar na zona de baixo, excepto se estiver na barra de segurança.
Assim que a bola bomba ultrapassar uma dada altura, troca-se de jogador.
Se a bola bomba tocar a zona de baixo, fora da barra de segurança do jogador, esta diminui de tamanho, até que com o valor zero, sendo nessa altura eliminado o jogador.
Após um jogador ser eliminado, o jogador seguinte apenas entra quando a bola bomba voltar a passar pela altura especificada.
Quando todos os jogadores forem eliminados, um novo jogo recomeça.
Caso passe a vez por todos os jogadores, sem que nenhum tenha diminuindo de tamanho, uma nova bola cai de cima, complicando o trajecto da bola bomba, e adicionando energia à totalidade das bolas.
A altura em que se troca de jogador, é determinada pelo percentil de 75% da altura de todas as bolas.
Sempre que a barra de um jogador diminua de tamanho, gerar um efeito em LEDs e num sensor piezoelectrico, gerando um outro efeito quando um jogador é eliminado, e quando o jogo termina e recomeça novo jogo.
http://arduino.cc/en/Main/ArduinoBoardUno
Placa para controlar através de programação, um conjunto de sensores/actuadores, com:
14 entradas/saídas digitais
6 entradas analógicas (precisão de 10 bits, valor entre 0 e 1023)
6 pins podem ter uma saída analógica (precisão de 8 bits, valor entre 0 e 255, pins: 3, 5, 6, 9, 10 e 11)
Programa em Arduíno:
setup - função executada uma vez;
loop - função em execução em ciclo infinito.
Algumas outras funções:
digitalWrite - escreve para um pin um determinado valor (LOW ou HIGH);
digitalRead - lê o valor num determinado pin
analogWrite - escreve para um pin (apenas os que aceitam saídas analógicas), um valor entre 0 e 255
analogRead - lê o valor de um determinado pin de entrada analógica, um valor entre 0 e 1023
pinMode - INPUT / OUTPUT / INPUT_PULLUP - coloca o pin em modo de entrada ou de saída. Se for em modo de entrada, pode-se especificar o INPUT_PULLUP de modo a que quando a entrada estiver em alta impedância (solta), o valor lido seja HIGH.
delay / millis - aguarda um determinado tempo / retorna o número de milisegundos desde que a placa foi iniciada
random / randomSeed - primitivas para geração de números aleatórios
// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)
delay(1000); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(1000); // wait for a second
}
int led = 13, espera=1000;

void setup() {
pinMode(led, OUTPUT);

// inicializar a semente aleatória, de uma leitura analógica de um pin não ligado (valor aleatório)
randomSeed(analogRead(0));
}

void loop() {
espera+=random(-250,250);
if(espera<200) espera=200;
if(espera>5000) espera=5000;
digitalWrite(led, HIGH);
delay(espera);
digitalWrite(led, LOW);
delay(espera);
}
Ligar o LED ao pin do Arduíno em modo de saída;
O valor 1 (HIGH) no Arduíno, corresponde à alimentação, 5 Volts, e o valor 0 (LOW), a 0 Volts.
Vantagem do Arduíno:
pode-se alterar o funcionamento, alterando o programa e mantendo a montagem inalterada
int ledSaida = 13, interruptor=2;

void setup() {
pinMode(ledSaida, OUTPUT);
pinMode(interruptor, INPUT);
}

void loop() {
int valor=digitalRead(interruptor);
digitalWrite(ledSaida, valor);
}
Igual ao LED, mas o pin do Arduíno tem de estar em modo de entada;
Neste caso, o programa reflecte o valor do interruptor no LED;
Vantagem do Arduíno:
Caso se queira, pode-se gravar os eventos, ou alterar a funcionalidade, por exemplo, desligando o LED passado algum tempo, algo que não seria possível com ligação directa.
Igual ao interruptor, mas tem de se evitar o estado de alta impedância;
Utilizar a resistência interna em cada pin do Arduíno:
pinMode(interruptor, INPUT_PULLUP);
int leds [] = {7,6,5,4};

void setup()
{
for(int i=0;i<4;i++)
pinMode(leds[i],OUTPUT);
}

void loop()
{
int valor=analogRead(A0);
// valor entre 0 e 1023, como há 4 LEDs dividir por 5 (apagado, 1, 2, 3, 4 leds)
valor/=(1024/5);
for(int i=0;i<4;i++)
if(valor>i) digitalWrite(leds[i],HIGH);
else digitalWrite(leds[i],LOW);
}
Utilizar os pins de entrada analógica;
Precisão de 10 bits, ou seja, a tensão de entrada entre 0 e 5 Volts, será convertida num valor entre 0 e 1023;
Esses pins são numerados de 14 a 19, ou usa-se as constantes A0 a A5.
int leds [] = {11,10,6,5};

void setup()
{
for(int i=0;i<4;i++)
pinMode(leds[i],OUTPUT);
}

void loop()
{
int valor=analogRead(A0);
// valor entre 0 e 1023, como há 4 LEDs, saída analógica, dividir por 4
// há 255 para cada LED, que é precisamente o valor da saída, pelo que
// nem há contas a fazer.

int nleds=valor/256;
int ultimoLed=valor%256;

for(int i=0;i<4;i++)
if(nleds>i) analogWrite(leds[i],255);
else if(nleds==i) analogWrite(leds[i],ultimoLed);
else digitalWrite(leds[i],0);
}
Utilizar pins com saídas analógicas
Valor das saídas com 8 bits (valor entre 0 e 255);
A montagem necessita apenas de trocar os pins dos LEDs, para os pins com PWM
Números dos pins no início do programa, facilita este tipo de alterações.
int piezo=11;

void setup()
{
pinMode(piezo,OUTPUT);
}

void loop()
{
int valor=analogRead(A0);
// valor entre 0 e 1023, re-escalar para a saída do sensor (0 a 255)
analogWrite(piezo,valor/4);
}
Sensor e actuador;
Vibra e emite som quando há variação de tensão eléctrica;
O inverso também;
Ligar o actuador com um potenciómetro;
Testar ligando directamente ao potenciómetro.
int piezo=A0, led=11;

void setup()
{
pinMode(led,OUTPUT);
pinMode(piezo,INPUT);
}

void loop()
{
int valor=analogRead(piezo);
// valor entre 0 e 1023, re-escalar para a saída do sensor (0 a 255)
analogWrite(led,valor/4);
}
O sensor é como se fosse um potenciómetro;
Como gera apenas diferenças de potencial de 2,5 Volts, há que re-escalar os valores lidos;
Testar ligando directamente o sensor ao LED.
int segmentos[]={4,5,3,6,7,9,2,8};

void setup()
{
for(int i=0;i<8;i++)
pinMode(segmentos[i],OUTPUT);
}

void OutputDisplay(int numero)
{
int digitos[10][8]={
{HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,LOW,LOW}, // 0
{LOW,HIGH,HIGH,LOW,LOW,LOW,LOW,LOW}, // 1
{HIGH,HIGH,LOW,HIGH,HIGH,LOW,HIGH,LOW}, // 2
{HIGH,HIGH,HIGH,HIGH,LOW,LOW,HIGH,LOW}, // 3
{LOW,HIGH,HIGH,LOW,LOW,HIGH,HIGH,LOW}, // 4
{HIGH,LOW,HIGH,HIGH,LOW,HIGH,HIGH,LOW}, // 5
{HIGH,LOW,HIGH,HIGH,HIGH,HIGH,HIGH,LOW}, // 6
{HIGH,HIGH,HIGH,LOW,LOW,LOW,LOW,LOW}, // 7
{HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,LOW}, // 8
{HIGH,HIGH,HIGH,HIGH,LOW,HIGH,HIGH,LOW}, // 9
};

for(int i=0;i<8;i++)
digitalWrite(segmentos[i],digitos[numero%10][i]);
}


void loop()
{
OutputDisplay(millis()/1000);
delay(1000);
}
Um display de 7 segmentos, é apenas um conjunto de 8 LEDs com ânodo ou cátodo comum;
Ligar como se fossem 8 LEDs separados;
Fazer uma função para facilmente colocar um dígito;
Não esquecer de colocar uma resistência por cada LED.
Acertar a ordem dos LEDs no programa.
int displays[]={8,9};
int entradas[]={7,6,5};
int segmentos[]={3,4,2,6,1,0,7,5};
int led=10;

void setup()
{
for(int i=0;i<3;i++)
pinMode(entradas[i],OUTPUT);
for(int i=0;i<2;i++) {
pinMode(displays[i],OUTPUT);
digitalWrite(displays[i],HIGH);
}
pinMode(led,OUTPUT);
}

void OutputDisplay(int numero, int local)
{
int digitos[10][8]={
{HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,LOW,LOW}, // 0
{LOW,HIGH,HIGH,LOW,LOW,LOW,LOW,LOW}, // 1
{HIGH,HIGH,LOW,HIGH,HIGH,LOW,HIGH,LOW}, // 2
{HIGH,HIGH,HIGH,HIGH,LOW,LOW,HIGH,LOW}, // 3
{LOW,HIGH,HIGH,LOW,LOW,HIGH,HIGH,LOW}, // 4
{HIGH,LOW,HIGH,HIGH,LOW,HIGH,HIGH,LOW}, // 5
{HIGH,LOW,HIGH,HIGH,HIGH,HIGH,HIGH,LOW}, // 6
{HIGH,HIGH,HIGH,LOW,LOW,LOW,LOW,LOW}, // 7
{HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,LOW}, // 8
{HIGH,HIGH,HIGH,HIGH,LOW,HIGH,HIGH,LOW}, // 9
};
// colocar todos os 8 bits
for(int i=0;i<8;i++) {
// colocar endereço do bit
for(int j=0, mascara=1;j<3;j++,mascara*=2)
if(i&mascara) digitalWrite(entradas[j],HIGH);
else digitalWrite(entradas[j],LOW);
// colocar valor do led
digitalWrite(led,digitos[numero%10][segmentos[i]]);
// gravar
digitalWrite(displays[local],LOW);
delay(10);
digitalWrite(displays[local],HIGH);
}
}

void loop()
{
int segundos=millis()/1000;
OutputDisplay(segundos%10, 0);
OutputDisplay((segundos/10)%10, 1);
}
int displays[]={8,9};
int segmentos[]={0,1,6,5,3,4,7,2};
int led=10;

void setup()
{
for(int i=0;i<2;i++) {
pinMode(displays[i],OUTPUT);
digitalWrite(displays[i],HIGH);
}
pinMode(led,OUTPUT);
}

void OutputDisplay(int numero, int local)
{
static int valores[2]={-1,-1};
int digitos[10][8]={
{HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,LOW,LOW}, // 0
{LOW,HIGH,HIGH,LOW,LOW,LOW,LOW,LOW}, // 1
{HIGH,HIGH,LOW,HIGH,HIGH,LOW,HIGH,LOW}, // 2
{HIGH,HIGH,HIGH,HIGH,LOW,LOW,HIGH,LOW}, // 3
{LOW,HIGH,HIGH,LOW,LOW,HIGH,HIGH,LOW}, // 4
{HIGH,LOW,HIGH,HIGH,LOW,HIGH,HIGH,LOW}, // 5
{HIGH,LOW,HIGH,HIGH,HIGH,HIGH,HIGH,LOW}, // 6
{HIGH,HIGH,HIGH,LOW,LOW,LOW,LOW,LOW}, // 7
{HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,HIGH,LOW}, // 8
{HIGH,HIGH,HIGH,HIGH,LOW,HIGH,HIGH,LOW}, // 9
};
// verificar se o valor no display é distinto
if(valores[local]!=numero%10) {
// colocar todos os 8 bits
for(int i=0;i<8;i++) {
// colocar valor do led
digitalWrite(led,digitos[numero%10][segmentos[i]]);
// gravar
digitalWrite(displays[local],LOW);
digitalWrite(displays[local],HIGH);
}
valores[local]=numero%10;
}
}

void loop()
{
int segundos=millis()/1000;
OutputDisplay(segundos, 0);
OutputDisplay(segundos/10, 1);
}
Interessa integrados com registos com entrada em série, e saída em paralelo
74LS259 - cada bit é endereçado;
74LS164 - entrada em série, cada bit "empurra" os outros;
Utilização de vários CI, é possível partilhar o bit de endereçamento / dados, desde que se active o CI correcto (bits de controlo).
Problema:
Utilizar a montagem anterior, e colocar um valor lido de um potenciómetro com dois dígitos
void loop()
{
int valor=analogRead(A0);
OutputDisplay(map(valor,0,1024,0,100), 0);
OutputDisplay(map(valor,0,1024,0,100)/10, 1);
}
void loop()
{
static int anterior=0;
int valor=analogRead(A0);
valor=0.5*valor+(1-0.5)*anterior;
anterior=valor;
OutputDisplay(map(valor,0,1024,0,100), 0);
OutputDisplay(map(valor,0,1024,0,100)/10, 1);
}
Alisamento exponencial negativo:
void loop()
{
static int anteriores[8]={0,0,0,0,0,0,0,0};
int valor=analogRead(A0);
// discartar o último valor e empurrar os restantes
for(int i=0;i<7;i++)
anteriores[i]=anteriores[i+1];
anteriores[7]=valor;
// colocar em valor, a média de todos os valores
valor=0;
for(int i=0;i<8;i++)
valor+=anteriores[i];
valor/=8;
OutputDisplay(map(valor,0,1024,0,100), 0);
OutputDisplay(map(valor,0,1024,0,100)/10, 1);
}
Média móvel:
Se o tempo não existir, a instalação apenas irá reagir directamente a um conjunto de sensores.
Manter a instalação anterior, e após o potenciómetro parar durante um segundo:
Reproduzir os números, 1 segundo por cada número;
Reproduzir exactamente o movimento, incluíndo o tempo em cada número.
Não utilizar a função "Delay"
// variáveis de gravação
int valoresGravados[100], numeroValores=0, tamanho=100;
long ultimoInstante=0, inatividade=1000; // 1 segundo
// gravar o valor lido, se distinto, retornando o último instante de tempo em que foi gravado um valor
void Gravar(int valor) {
// verificar se o valor é distinto do anterior, c.c. ignorar
if(numeroValores==0 || valoresGravados[numeroValores-1]!=valor) {
// verificar se é altura de se fazer um reset, no caso de ter existido uma parágem longa
if(millis()-ultimoInstante>inatividade)
numeroValores=0;
// carregar até ao limite de memória
if(numeroValores<tamanho)
valoresGravados[numeroValores++]=valor;
else {
// descartar o valor mais antigo
for(int i=0;i<tamanho-1;i++)
valoresGravados[i]=valoresGravados[i+1];
valoresGravados[tamanho-1]=valor;
}
// último instante em que houve alteração
ultimoInstante=millis();
}
}

// reproduzir o valor, que retornará o valor correpondente ao instante pedido
int Reproduzir(long instante) {
// uma nota por segundo
long indice=instante/1000;
if(indice<numeroValores)
return valoresGravados[indice];
// sequência já acabou, retornar 0 ou um código que indique que a sequência já acabou
return 0;
}

void loop()
{
static int anterior;
int valorBruto=analogRead(A0);
int valor;
valorBruto=0.5*valorBruto+(1-0.5)*anterior;
anterior=valorBruto;
valor=map(valorBruto,0,1024,0,100);
Gravar(valor);
if(millis()-ultimoInstante>inatividade) // 1 segundo de inactividade
valor=Reproduzir(millis()-ultimoInstante-inatividade); // reproduzir, indicando o instante de tempo
// a reprodução é nos displays de 7 segmentos, mas poderia ser num LED
OutputDisplay(valor, 0);
OutputDisplay(valor/10, 1);
}
// variáveis de gravação
int valoresGravados[100], numeroValores=0, tamanho=100;
long instantesGravados[100];
long ultimoInstante=0, inatividade=1000; // 1 segundo
// gravar o valor lido, se distinto, retornando o último instante de tempo em que foi gravado um valor
void Gravar(int valor) {
// verificar se o valor é distinto do anterior, c.c. ignorar
if(numeroValores==0 || valoresGravados[numeroValores-1]!=valor) {
// verificar se é altura de se fazer um reset, no caso de ter existido uma parágem longa
if(millis()-ultimoInstante>inatividade)
numeroValores=0;
// carregar até ao limite de memória
if(numeroValores<tamanho) {
valoresGravados[numeroValores]=valor;
// gravar também o instante
instantesGravados[numeroValores]=millis();
numeroValores++;
} else {
// descartar o valor mais antigo
for(int i=0;i<tamanho-1;i++) {
valoresGravados[i]=valoresGravados[i+1];
instantesGravados[i]=instantesGravados[i+1];
}
valoresGravados[tamanho-1]=valor;
instantesGravados[tamanho-1]=millis();
}
// último instante em que houve alteração
ultimoInstante=millis();
}
}

// reproduzir o valor, que retornará o valor correpondente ao instante pedido
int Reproduzir(long instante) {
// obter o índice do valor correspondente ao instante pedido (subtrair pelo primeiro)
for(long indice=1;indice<numeroValores;indice++)
if(instantesGravados[indice]-instantesGravados[0]>instante)
// devolver o valor de indice-1, já que o instante de indice já é posterior
return valoresGravados[indice-1];
// retornar a última nota durante o tempo de inactividade
if(numeroValores>0 && instantesGravados[numeroValores-1]+inatividade-instantesGravados[0]>instante)
return valoresGravados[numeroValores-1];
// sequência já acabou, retornar 0 ou um código que indique que a sequência já acabou
return 0;
}
void setup() {
Serial.begin(9600);
}

void loop() {
static int segundos=0;
if(segundos!=millis()/1000) {
segundos=millis()/1000;
Serial.print("Segundos: ");
Serial.println(segundos);
}
}
Envio de informação do Arduíno para o PC, e monitorização no Ambiente Arduíno
Chega ao PC:
No Arduíno:
import processing.serial.*;
Serial myPort;

void setup() {
println(Serial.list());
myPort = new Serial(this, Serial.list()[0], 9600);
}

void draw() {
while (myPort.available() > 0) {
String inBuffer = myPort.readString();
if (inBuffer != null) {
print(inBuffer);
}
}
}
1. Código no Processing:
int botao=3, interruptor=2, potenciometro=A0;
void setup() {
pinMode(botao, INPUT_PULLUP);
pinMode(interruptor, INPUT);
Serial.begin(9600);
}

void loop() {
static int vbotao=LOW;
static int vinterruptor=LOW;
static int vpotenciometro=0;
static int venviado=0;
int atualizado=0;
if(vbotao!=digitalRead(botao)) {
vbotao=digitalRead(botao);
atualizado=1;
}
if(vinterruptor!=digitalRead(interruptor)) {
vinterruptor=digitalRead(interruptor);
atualizado=1;
}
if(vpotenciometro!=analogRead(potenciometro)) {
// enviar informação apenas se for muito diferente
vpotenciometro=analogRead(potenciometro);
if(abs(vpotenciometro-venviado)>10)
atualizado=1;
}
if(atualizado) {
Serial.print("botao: ");
Serial.print(vbotao);
Serial.print(", interruptor: ");
Serial.print(vinterruptor);
Serial.print(", potenciometro: ");
Serial.println(vpotenciometro);
venviado=vpotenciometro;
}
}
3. No Arduíno:
2. Montagem:
4. Output no Processing:
import processing.serial.*;
Serial myPort;
String entrada; // string de entrada
void setup() {
// List all the available serial ports:
println(Serial.list());
// Open the port you are using at the rate you want:
myPort = new Serial(this, Serial.list()[0], 9600);
}

void draw() {
while (myPort.available() > 0) {
String inBuffer = myPort.readString();
if (inBuffer != null) {
entrada = entrada + inBuffer;
print(inBuffer);
// verificar se tem dados para processar
String [] tokens=splitTokens(entrada, " ,:\n\r");
for(int i=0;i<=tokens.length-6;i++)
if(tokens[i].equals("botao")) {
// processar potenciómetro
int valor=int(tokens[i+5])/4;
// processar interruptor (inverte o valor)
if(int(tokens[i+3])!=0)
valor=255-valor;
// processar botão (mostra o valor ou não)
if(int(tokens[i+1])!=0)
background(valor);
else
background(0);
// limpar dados
entrada="";
}
}
}
}
5. Processar dados:
6. Necessário token de fim de pacote.
No Processing:
import processing.serial.*;
Serial myPort;
String entrada; // string de entrada
void setup() {
myPort = new Serial(this, Serial.list()[0], 9600);
}

void draw()
{
}

void mouseMoved()
{
if(pmouseX!=mouseX)
myPort.write(255*mouseX/width);
}
No Arduíno:
int led=5;
void setup() {
pinMode(led, OUTPUT);
Serial.begin(9600);
}

void loop() {
// leitura, e reflexo no LED
if(Serial.available()>0) {
int valor=Serial.read();
analogWrite(led,valor);
}
}
Full transcript