quarta-feira, 11 de novembro de 2009

Lendo Botao com Arduino

Como controlar um LED a partir de um BOTAO usando o ARDUINO

CIRCUITO:

















int led = 13; // pino do LED
int botao =2; // pino do botão
int val = 0; // variavel de leitura

void setup(){
pinMode(led, OUTPUT); // LED como saida
pinMode(botao, INPUT); // botão como saida
}

void loop(){
val = digitalRead(botao); // Lê botão
if (val == HIGH) { // se foi apertado
digitalWrite(led, LOW); // desliga LED
}
else {
digitalWrite(led, HIGH); // liga led
}
}

EXPLICAÇAO:

Como de padrao o LED fica configurado como OUTPUT e o BOTAO como entrada (INPUT).
A variavel val recebe a leitura fornecida pelo botao. Quando apertado o valor fica como HIGH, portanto liga o LED, caso contrario desliga o LED.

Muito simples ;)

Pedro Pavan


domingo, 8 de novembro de 2009

Controlando SERVOS com o ARDUINO.

Aqui está representado um código simples que exemplifica a utilização de três SERVOS controlados pelo ARDUINO. SERVOS são amplamente aplicados no desenvolvimento de artefatos robóticos devido a sua alta performance e a capacidade de aplicação de torques que dificilmente seriam capazes de se atingir com outros tipos de aplicação com motores que não possuam as características que os SERVOS possuem.

O que diferencia um motor ordinário de um SERVO é o conjunto de engrenagens de redução que este último possui, o que lhe permite, mediante um pequeno motor, ser capaz de deslocar grandes massas, se utilizando de baixa tensão (a grande maioria trabalha com tensão nominal de 5 V) e pequeno tamanho.

Com o uso da biblioteca SERVO.H, um ou mais servos podem ser utilizados diretamente na placa de desenvolvimento do ARDUINO, sem que nenhuma compensação de tensão tenha que ser feita, uma vez que ambos possuem a mesma tensão de trabalho (5 V).

Mas lembre-se sempre de ler as especificações dos dispositivos que está trabalhando na placa de desenvolvimento do ARDUINO, pois é necessário que se atente para as taxas de correntes que são aplicadas, que na maioria das vezes não devem ultrapassar a casa dos 40 mA (mile ampéres) em cada pino, pois correntes acima deste valor podem prejudicar os dispositivos internos do seu micro controlador que compõe a placa de desenvolvimento do ARDUINO.

Agora vá em frente, comece a trabalhar com estes e outros dispositivos, e tenha sempre em mente que o limite para seu desenvolvimento com o ARDUINO é sua imaginação!

Por:

José Tadeu Aldrigue.


Visão Superior do Projeto:


Vista Inferior do Projeto, onde se pode ver acoplado a placa de Programação e Desenvolvimento do ARDUINO, bem como os SERVOS que executam sua locomoção:


Código que controla este projeto no ARDUINO:

/* Programa para projeto entitulado Formiga. */

INTEGRANTE DO PROJETO:

Denis Oliveira

José Tadeu Aldrigue

Pedro Pavan

Rudy Paulo de Vasconcellos Júnior

Este é um código básico para ser utilizado com o ARDUINO, para a maniulação simples de SERVOS, cujo objeto já possui uma biblioteca pronta para uso.

Servos são mecanismos muito importantes na área de robótica pela sua escala reduzida e alto torque desenvolvido. Alguns podem levantar um peso de

5 Kg se colocados a uma distancia que vaira em torno de 0 a 1 cm do seu eixo de rotação.

Sua utilização se dá no mecanismo de braços, e movimentos robóticos, bem como a movimentação de rodas para o deslocamento de diversos tipos de fins,

e para tanto o servo deve ser modofocade em seu Hardware para que o pino de fim de curso, que geralmente está associado a última engrenagem de redução, deve ser retirado, para que o servo possa ter rotação livre, ou seja, maior que 180 graus.



#include < Servo.h >
// Biblioteca para a utilização de Servos com o Microcontrolador ATMEGA8

// declaração dos objetos SERVO:

Servo perna_esq; // Criação de um objeto que permite controlar o servo que moverá a // perna esquerda;
Servo perna_dir; // Criação de um objeto que permite controlar o servo que moverá a // perna direita;
Servo centro; // Criação de um objeto que permite controlar o servo que moverá as // pernas do centro;

int center = 90; //inicialização da variavel posiçao, definida para 90 graus;
int range=45; //taxa de variacao do passo que cada servo executará;
int contagem; //inicialização da variavel que sertivrá de contador;

//declaração dos pinos:
void setup() //Declaração dos objetos controlados pelo Microcontrolador;
{
//definição da pinagem dos servos das pernas (10,11) e do centro(12):
perna_esq.attach(10); // Porta onde irá ser ligado Perna Esquerda
perna_dir.attach(11); // Porta onde irá ser ligado Perna Direita
centro.attach(12); // Porta onde irá ser ligado o Centro
//inicialização do console de entrada de valores COM 4, que fornecerá mensagens a respeito de cada função sendo processada a cada instante;
Serial.begin(9600); //Inicializa porta serial
}

void loop(){ //Este laço é responsável pela execução sequencial e circular dos comandos -
//-que estão em seu escopo, até que uma condição de parada ou interrupção // seja disparada;
//Primeiro passo Esquerdo
// Inicialização dos servos: Coloca todos os servos declarados no programa para a posição inicial declarada em 'center', no começo do programa;
for(contagem=0;contagem<=20;contagem++) {
Serial.write("Inicializando Sistema em 1 Segundo:\n\n"); //Mostra mensagem de inicialização dos Servos;
delay(100); //Aguarda 1 segundo(100 ms(mile-segundos)) antes de executar a próxima instrução;
centro.write(center); //Os servos começam a serem inicializados;
Serial.write("Inicializei o centro;\n");
perna_dir.write(center);

Serial.write("Inicializei Perna Direita\n");
perna_esq.write(center);
Serial.write("Inicializei Perna Esquerda\n\n");
delay(200); //Término da inicialização dos servos;

//movimentacao das pernas do protótipo:
//primeiro passo da perna direita:
centro.write(center-range); //Movimento da perna central direita;
Serial.write("Movimentei Centro Direita;\n\n");
delay(800);
perna_dir.write(center-range-20); //Movimento da perna direita posterior e anterior para frente;
Serial.write("Moviementei Perna Direita para Tras\n");
delay(500);
centro.write(center); //retorno da perna central para a posição inicial;
Serial.write("Retornei Centro\n\n");
delay(800); // Espera de ? milisegundos para que o servo possa chegar á sua posiçao

// Segundo Passo Esquerdo:
centro.write(center+range); //Movimento da perna central esquerda;
Serial.write("Movimentei Centro para Esquerda\n");
delay(800);
perna_esq.write(center+range+20); //Movimento da perna esquerda posterior e anterior para frente;
Serial.write("Movimentei Perna Esquerda para Tras\n");
delay(500);
centro.write(center); //retorno da perna central para a posição inicial;
Serial.write("Retornei Centro\n\n");
delay(800);
Serial.write("Terminei um Passo!!!\n\n"); //Mensagem de confirmação do primeiro passo completo;
}

}

quinta-feira, 5 de novembro de 2009

Utilizando sensor de Luminosidade com Arduino
























(clique nas imagens para visualizar melhor)




Este codigo nos permite fazer a leitura com um sensor de luminosidade, armazenar este valor e controlar a intensidade do brilho de um led.


Vamos ao codigo...

Primeiro é preciso calibrar o sensor, ou seja, definir um minimo e máximo para que ele possa trabalhar corretamente. Este processo é feito durante 5 segundos utilizando a função millis() e uma variavel flag localizada no pino 13. Enquanto o led do pino 13 estiver aceso saberemos que o sensor esta sendo calibrado.
Agora no void loop() usamos a função analogRead() para fazer a leitura analogica do sensor, que sera armazenada na variavel leirtura. Para trabalharmos de uma forma melhor vamos deixar o valor de leitura entre 0 e 255, para isso, vamos usar a função map(). Note que ela recebe 5 parametros de entrada. O valor propriamente dito, o valor minimo e maximo, e os novos valores. Assim esteremos mudando a faixa de valor que antigamente era de 0 a 1023 para 0 a 255.
A função constrain() nos garante que esse valor ficara na faixa estabelecida pelo map().
Por fim escrevemos com o valor obtido na leitura do sensor de luminosidade.

Neste pequeno exemplo foi mostrado como controlar o brilho do led utilizando valores lidos por um sensor de luminosidade com o Arduino ;)

Pedro Pavan

sexta-feira, 30 de outubro de 2009

O Hello World do Arduino

Piscar um led é o primeiro passo para começar a trabalhar com a plataforma Arduino. O codigo é muito simples e didatico.


int LED = 8; // definindo LED no pino 8
int tempo = 1000; // tempo de espera 1segundo

void setup(){ // executa apenas uma vez
pinMode(LED, OUTPUT); // pino LED saida

}
void loop(){ // laço contínuo
digitalWrite(LED, HIGH); // acende LED
delay(1000); // espera 1s
digitalWrite(LED, LOW); // apaga LED
delay(tempo); // espera 1s

}

EXPLICAÇÂO:

Primeiramente vamos definir as variaveis e em quais pinos elas atuarao. Para representar o led foi criada a variavel LED com o valor 8, ou seja, o led vai plugado na “perninha” 8 do Arduino.Foi criada uma variavel tempo com valor de 1000 (em milisegundos), que corresponde a 1 segundo.

No void setup vai a configuração inicial, esta parte sera executada apenas uma vez, no inicio.

A função pinMode serve para setar os pinos e recebe dois parametros. No primeiro recebe o valor do pino que queremos setar, no nosso caso a variavel LED armazena o valor 8, o nosso pino. O outro parametro nos mostra qual a função da “perninha”, INPUT ou OUTPUT, no caso o led é de saida, portanto OUTPUT.

Agora nos resta a função void loop, como o proprio nome já diz o codigo ficara em loop.

Finalmente a parte que realmente faremos o “Olá Mundo”. Usando a função digitalWrite que escreve na porta digital 8, denominado pela variavel LED mandando um sinal HIGH. Aguardamos um segundo e apagamos o led usando LOW, aguardamos mais um segundo para que possamos ver o led apagado tambem. Dai em diante o codigo ficara se repetindo desta forma.

Uma boa pratica de programação foi ter criado a variavel tempo. Suponhamos que agora eu quero meu led piscando a cada 5 segundos. Basta alterar o valor da variavel tempo para 5000.

Vejamos que com poucas linhas foi possivel fazer um “Hello World” usando o Arduino. Trata-se de uma programação bem facil que qualquer um pode aprender. Este é apenas o inicio.

Pedro Pavan

quinta-feira, 29 de outubro de 2009

O melhor amigo do Arduino

  Dizem que o melhor amigo do homem é o cachorro, quem já passou por um aperto financeiro sabe que os amigos humanóides costumam se tele transportar para um universo paralelo nessas ocasiões. Independente de seu saldo bancário, sempre que você voltar para casa vai receber o cumprimento característico de um cão, uma seqüência de abanos de cauda.
   O Arduino também tem seu melhor amigo, ele não tem cauda, mas o protege do excesso de corrente nos pinos, que pode ocasionar a queima do mesmo e em alguns casos o pior, ou seja, perder o microcontrolador completamente.
   Os pinos do Arduino não podem fornecer mais do que 40mA de corrente direta, um valor normalmente adotados por outros fabricantes como a Microchip que fabrica a linha PIC. Desta forma sempre que for ligar algum dispositivo ao Arduino deve-se limitar essa corrente, na maioria das vezes usando-se um resistor de valor adequado.
     Para calcular o resistor continua valendo a velha e conhecida lei de Ohm, V=r.i, basta a aplicação direta da fórmula para saber o valor a ser utilizado. Por exemplo, para se fazer o famoso prosaico “Olá mundo!” do Arduino, basta um LED e um resistor. Lápis e papel na mão, sigam-me os bons:
Tensão da fonte: 5 volts
Tensão no LED: 2,1 volts (varia com a cor, o ideal é consultar o fabricante)
Corrente fornecida pelo pino do Arduino: 20 mili amperes (metade da corrente máxima)
Valor do resistor: ?
Capacidade de dissipação do resistor: ?
R = V / I = (5 Volt - 2.1 Volt) / 25 mA = 116 Ohm
   Note que a tensão sobre o resistor vai ser o valor da total da fonte menos a queda de tensão no LED. Como 116 Ohm não é um valor comercial, o próximo maior deve ser utilizado ou mesmo um valor acima, sempre com a intenção de poupar o pino do Arduino de uma sobre carga. Portanto 120 ou 150 Ohm seriam indicados para o trabalho de limitar a corrente. Recalculando:
R = V / I = (5 Volt - 2 Volt) / 20 mA = 150 Ohm
E a potência do resistor? Vamos lá:
P = V x I = 3 Volt x 20 mA = 60 mW
Bem abaixo do valor típico encontrado nas lojas que é de 250 mW.
   Pronto agora você já está apto a criar seu próprio “Hello World!”, talvez usando código Morse através das piscadas do LED, só para não ser mais um na multidão. Isso é o que atrai tantas pessoas para a plataforma do Arduino, você pode ver seu código “se mexer” literalmente e quem sabe lembrar-se da salada do bandejão da Universidade...
   Para terminar, os LED infravermelhos usados em controle remoto apresentam uma queda de tensão menor e uma corrente direta muito maior que os LEDs convencionais, da ordem de 50 mA, bem acima do que pode fornecer um pino do Arduino. Alem é claro de não serem visíveis a nós simples programadores. Reza a lenda que um Mestre Programador Jedi é capaz de enxergar, como estou longe de algum para confirmar. Para ligar um desses é preciso um “driver” mas, este  assunto fica para outro estória.

Neste link tem muita informação sobre LED, além de um prático calculator de resistores.


Rudy Paulo de Vasconcellos Júnior


segunda-feira, 26 de outubro de 2009

MCU DAY - Texas Instruments



Ocorreu no dia 22 de Outubro no EESC - Dep. Engenharia Elétrica da USP uma palestra da Texas Instruments sobre as três principais linhas de microprocessadores: MCUs MSP430™, MCUs C2000™ e Stellaris®.
Foi uma palestra cheia de detalhes minuciosos sobre cada arquitetura e suas areas de aplicação. Podemos ver de perto o poder da linha Stellaris® usando o processador ARM o que instigou a buscar informações para implementar nesta arquitetura.
Fica como experiência única para os participantes e uma bagagem muito boa de estudos para o grupo.
Link -> MCU DAY
Autor: Denis