Colocando seu Arduino para funcionar:

1º Passo: Baixe a IDE 1.0 do Arduino aqui de acordo com seu Sistema Operacional: (ex: Windows, Mac, Linux): http://arduino.cc/en/Main/Software e extraia em um lugar de sua escolha;

2º Passo: Conecte seu Arduino no seu computador com um cabo USB;

3º Passo: (ATENÇÃO: Este passo é somente para usuários de WINDOWS, caso não for usuário de WINDOWS passe para o próximo passo) Ao conectar seu Arduino no computador, irá aparecer um balão no canto direito inferior da tela dizendo que o hardware não foi reconhecido. Clique no balão e assim aparecerá uma janela para instalar o driver. O driver está localizado dentro da pasta Arduino/drivers/. Instale o driver referente a sua placa Arduino (ex: Arduino UNO Rev.3 → driver Arduino UNO REV3.inf / Arduino DUEMILANOVE → indique a pasta FTDI USB DRIVERS).

4º Passo: Abra a IDE do Arduino clicando duas vezes no ícone chamado arduino dentro da pasta Arduino.

5º Passo: Na IDE do Arduino, clique em Tools/board e selecione a sua placa. Agora vá em Tools/Serial port e selecione a porta a qual seu Arduino está conectado. (verifique qual porta ele realmente está conectado. Ex: WINDOWS → COM4, LINUX → ttyUSBx ou ttyACMx e MAC /dev/tty.usbmodemxxxxx, sendo 'x' o número da porta).

6º Passo: Passando programação para Arduino:

1º Exemplo: Agora vá em File/Examples/Basics/Blink/. Abrirá uma nova janela com a programação do Blink. Clique em upload. Assim que o Upload terminar, você verá o led da placa Arduino piscar.

2º Exemplo: Agora faça a seguinte ligação utilizando um pushbutton e um resistor de 10Kohm:

Vá File/Examples/2.Digital/Button e irá abrir uma nova janela com a programação.

Faça o UPLOAD. Assim que terminar, aperte o botão e o LED “L” na placa acenderá.

3º Exemplo: Agora, com um potenciometro, faça a seguinte ligação:

Vá em File/Examples/1. Basic/AnalogReadSerial/ e irá aparecer a programação a seguir:

/*

AnalogReadSerial

Reads an analog input on pin 0, prints the result to the serial monitor

This example code is in the public domain.

*/

void setup() {

Serial.begin(9600);

}

void loop() {

int sensorValue = analogRead(A0);

Serial.println(sensorValue, DEC);

}

Agora abra o Serial Monitor, gire o potenciometro de um lado para outro e você verá como a figura abaixo:

Pronto, agora caso você queira brincar mais, você pode entrar nos sites de referências e aprender mais!!

Controle pelo Teclado

Esse tipo de programação é bem tranquilo de fazer e de entender também, mas para fazer isso precisa ter em mãos a Tabela ASCII (American Standard Code for Information Interchange) para fazer a programação, usamos só o valor decimal.

O que está marcado em amarelo não é utilizado, é o valor em decimal e ao lado o correspondente.

     Vamos usar nessa programação, duas novas funções Serial.read() e oSerial.available():

-Serial: Ele se comunica nos pinos digitais 0 (RX) e 1 (TX), bem como com o computador via USB.

-read: Serve para lê as entradas de dados do serial.

-available: Serve para obter o números de bits disponível para a leitura da porta serial.

void setup()
{
 Serial.begin(9600);
}

void loop()

{

  if(Serial.available()>0)

  {

    n = Serial.read();

    Serial.print("Voce digitou: ");

    Serial.println(n, BYTE); // Imprime na tela o valor do telhado em BYTE

    if(n==119)  // tecla w (minusculo)

    {

      //Tecla ação 1, ex.: se for um carrinho anda para frente

    }

    if(n==115)  // tecla s (minusculo)

    {

      //Tecla ação 2, ex.: carrinho anda para tras

    }

    if(n==100)  // tecla d (minusculo)

    {

      //Tecla ação 3, ex.: carrinho anda para a direita

    }

    if(n==97)  // tecla a (minusculo)

    {

      //Tecla ação 4, ex.: carrinho anda para a esquerda

    }

  }

}

     Esse n eu declarei como uma variável qualquer, dei exemplos de 4 ações só mas podemos criar varias ações para ficar controlando pelo teclado. Lembrando que novoid setup() precisa colocar o Serial.begin(9600). Também usei como exemplo para controlar carrinho, mas podemos usar para controlar leds, fazer teclado musical (usando um piezo) (mas tem que ficar de olho nos valores).

     Mas para funcionar, assim que passar a programação para o arduino, clica no Serial Monitor e abrirá uma janela como a imagem a seguir. Na barra onde digitamos a tecla e logo em seguida aperte enter, pronto a função que você escolhe irá funcionar.

Sensor de Toque

A programação do Sensor de Toque, praticamente é igual ao do Sensor de Luz, mas é mais pratico usar esse Sensor numa porta Digital do Arduino, porque nesse sensor você só irá ligar e desligar algo, vai ser 0 quando estiver pressionado ou 1 quando não pressionar o botão (ou vice versa dependendo do circuito que você queira), na minha opinião, o mais adequado para isso seria usar o push button. Mas podendo fazer numa porta analógica, ai seria melhor usar a Chave Switch porque podemos controlar um pouco a intensidade do toque no sensor.

     Quando usamos as portas analógicas do Arduino, o arduino irá fazer uma leitura de 0-1023 na porta digital, a leitura vai ser 0-1, mas na programação colocamos HIGH (1) e LOW (0).

     Para quem não conhece o que é um Push Button ou Chave Switch, logo abaixo tem foto desses sensores e para quem não sabe montar o Sistema do Sensor de Toque aqui o link para saber montar.

     Como disse a programação não tem mistério praticamente o idem do Sensor de Luz, mas nesse aqui estou usando o PushButton para controlar os LEDs mas a partir disso dá para usar no sensor de toque, por exemplo o projeto desviar de obstáculos.

     O circuito do PushButton é fácil de montar mas tem que prestar atenção no botão nos terminais, ver onde ficar o NA e o NF (Normalmente Aberto e Fechado). O circuito do RGB é independente do botão os circuitos não se misturam como mostra a imagem a seguir:

Programação:

int led13 = 13;
int R = 11;
int G = 10;
int B = 9;
int botao13 = 2;
int valor13 = 0;
int botaoR = 3;
int valorR = 0;
int botaoG = 4;
int valorG = 0;
int botaoB = 5;
int valorB = 0;
int botaoReset = 6;
int valorReset = 0;
void setup()
{
  pinMode(led13, OUTPUT);
  pinMode(R, OUTPUT);
  pinMode(G, OUTPUT);
  pinMode(B, OUTPUT);
  pinMode(botao13, INPUT);
  pinMode(botaoR, INPUT);
  pinMode(botaoG, INPUT);
  pinMode(botaoB, INPUT);
  pinMode(botaoReset, INPUT);
}
void loop()
{
  // Liga a Desliga o Led13
  valor13=digitalRead(botao13);
  if(valor13 == HIGH)
  {
    digitalWrite(led13, HIGH);
  }
  else
  {
    digitalWrite(led13, LOW);
  }
  // Liga a Desliga Cores do RGB
  valorR=digitalRead(botaoR);
  valorG=digitalRead(botaoG);
  valorB=digitalRead(botaoB);
  valorReset=digitalRead(botaoReset);
  if(valorR == HIGH)
  {
    digitalWrite(R, HIGH);
    digitalWrite(G, LOW);
    digitalWrite(B, LOW);
  }
  if(valorG == HIGH)
  {
    digitalWrite(R, LOW);
    digitalWrite(G, HIGH);
    digitalWrite(B, LOW);
  }
  if(valorB == HIGH)
  {
    digitalWrite(R, LOW);
    digitalWrite(G, LOW);
    digitalWrite(B, HIGH);
  }
  if(valorReset == HIGH)
  {
    digitalWrite(R, LOW);
    digitalWrite(G, LOW);
    digitalWrite(B, LOW);
  }
}

     Explicando a primeira parte da programação, o 1º botão só vai servir para ligar o LED quando for pressionado, quando não for, o LED fica apagado. Para fazer isso como vimos usei a programação else serve para fazer o contrario (dependendo da programação) do if, o Arduino irá ler assim: "SE (if) botão for igual a 1 (HIGH), o LED acende, DO CONTRARIO (else) caso o botão não fique pressionado o LED apaga. Não colocando o else, o Microcontrolador irá entender que quando pressionar uma vez o LED ficará acesso e não apaga.

     Na programação, devemos sempre colocar até os mínimos detalhes como você quer, quando quer que uma situação (exemplo) o LED acenda e outra situação o LED apague, porque se não pode gerar conflito dependendo da programação.

     Na segunda parte da programação, ai usei 4 botões para isso, cada um vai ligar uma única cor (sem fazer misturas de cores) e o quarto botão vai ser um botão de Reset que vai apagar todas as cores independendo de qual cor esteja acesso.

 Como falei um pouco antes, eu tive que detalhar a programação falando como eu queria que funcionasse, que se eu aperta o botaoR, quero que só a cor vermelha acenda fique HIGH e outras LOW. Caso aperte o botaoG quero que só o verde acenda e os outros apaguem e caso eu aperte o botaoB só o azul fique HIGH e o resto LOW. Mas tipo fazendo isso em qualquer sequencia de quando eu apertar o botão, ai no botaoReset como quero que apague tudo deixei claro que quando eu aperta-se o botão, todos vão se apagar, vão ficar LOW.

Potenciometro

Nessa postagem irei explicar função nova, estou utilizando potenciômetro para controlar o tempo em que um LED vai piscar e a intensidade de luz do LED RGB, usando nas portas PWM.

     Nessa "aula" estou usando 4 potenciômetros, 1 LED RGB e 3 resistores de 220ohm para proteger o LED. 1 potenciômetro é para o LED do pino 13 e outros 3 para cada cor do LED RGB. O circuito do potenciômetro com os LED RGB fica assim:

Esse circuito é para 1 potenciômetro, mas é idem com todos os potenciômetros.

Programação:

const int led = 13;
int T = 0;
const int R = 11;
const int G = 10;
const int B = 9;
const int potled = 0;
const int potR = 1;
const int potG = 2;
const int potB = 3;
void setup()
{
  pinMode(led, OUTPUT);
  pinMode(R, OUTPUT);  pinMode(G, OUTPUT);

  pinMode(B, OUTPUT);  Serial.begin(9600);
}
void loop()
{
  //Programação De Tempo do LED que pisca
  T=analogRead(potled);
  digitalWrite(led, HIGH);
  delay(T);
  digitalWrite(led, LOW);
  delay(T);                                                                                                                                                               //Programação de Cores com RGB                                                                                                                                   int valorR=analogRead(potR);                                                                                                              int valorG=analogRead(potG);

  int valorB=analogRead(potB);

  int pwmr = map(valorR,0,1023,0,255);

  int pwmg = map(valorG,0,1023,0,255);

  int pwmb = map(valorB,0,1023,0,255);

  analogWrite(R, pwmr);

  analogWrite(G, pwmg);

  analogWrite(B, pwmb);

}

     Agora irei explicar a função matemática map() e variável const:                                 - const -> A const palavra-chave significa constante. É uma variável qualificador que modifica o comportamento da variável, tornando uma variável " read-only ". Isto significa que a variável pode ser usado apenas como qualquer outra variável de seu tipo, mas seu valor não pode ser alterado. Você vai ter um erro do compilador, se você tentar atribuir um valor a uma const variável.

- map() -> map serve para fazer calculo de um intervalo para o outro, map(valor, ValorInicialDesligado, ValorInicialLigado, ValorFinalDesligado, ValorFinalLigado), ou seja, o ValorInicalDesligado ficará mapeado em ValorFinalDesligado, e o ValorInicalLigado ficará mapeado em ValorFinalLigado.

OBS.: Nos valores Desligado, não quer dizer que o valor tem quer se menor do que os valores Ligados, podendo fazer o contrario, o valor Desligado ser maior que os Ligado. Também podendo usar valores negativos.

Motores DC

Motores DC

     Primeiramente, para ligar um motor DC no arduino, precisamos montar um pequeno circuito. Porque o arduino não tem corrente suficiente para ligar um motor, a corrente que o arduino tem é de 40mA e dependendo do motor, precisa de mais que isso, uns 50mA em diante.

     Existem n maneiras para montar um circuito para pode ligar o motor, vou mostrar só uma delas como mostra a imagem a seguir:

     O resistor que usei é de 1kohm, diodo 1N4007, transistor TIP120 e a bateria é que serve para ligar o motor. Lembrando também que existe varias maneiras para ligar um motor, a programação praticamente é igual a do Blink também pode ser feita pelo for mas precisa usar uma porta pwm, só que em vez do LED vai ligar um motor DC.

Programação:

int motor= 9;  //Variável 9 que declarei como motor
void setup()
{
  pinMode(motor, OUTPUT);  //Porta Digital do arduino, pino 9 (pwm)
}

void loop()

{

  digitalWrite(motor, HIGH); //Motor Liga por

  delay(1000);                   // 1segundo = 1000 milissegundos

  digitalWrite(motor, LOW); //Motor Desliga por

  delay(1000);                  //1segundo = 1000 milissegundos

}

     Como vocês viram, mudou quase nada da programação Blink, mas como a porta 9, é uma porta pwm, logo vocês podem mudar a corrente, em vez de HIGH pode-se colocar 255 (corrente máxima ou outro valor para andar) e em vez de LOW pode colocar como 0 (corrente nula ou um valor muito baixo para ele andar bem de vagar), mas lembrando de que precisa mudar de digitalWrite para analogWrite. Fazendo isso, podemos controlar a velocidade dos motores, leds, qualquer componente.

Tradicional pisca - pisca

Blink - Piscando LED

      Aqui vai uma breve explicação para programação de piscar um led, esse é um exemplo clássico que todos quando recebem o arduino usa para testa-lo se está funcionando. Mas na programação existe várias maneiras para fazer a mesma coisa, no caso vou explicar a programação básica e uma, um pouquinho mais avançada para quem está começando agora com o arduino, que é a programação por for.

1-Programação Básica:

    Vou fazer a programação toda e depois vou explicar em partes. Lembrando que no próprio arduino tem um led conectado a porta 13.

int led= 13; //Declarei que led é a variável 13

void setup()

{

  pinMode(led, OUTPUT); //Agora utilizei essa variável e disse que ela é a porta 13 do arduino

}

void loop()

{

  digitalWrite(led, HIGH); // Led ficará ligado

  delay(1000);                    //Por 1000 milissegundos

  digitalWrite(led, LOW); //Led irá ficar desligado

  delay(1000);                   //Por 1000 milissegundos

}

     No início da programação quando declarei que led = 13, esse valor serial uma variável, mas no nosso consentimento, na nossa cabeça fica como se fosse já a porta do arduino, mas é uma variável qualquer.

     No void setup(); que é a preparação da programação, ai sim digamos falamos da porta do arduino, declarei que esse valor vai sair dados, vai sair tensão (se fosse INPUT, seria o contrario, entraria dados);

     No void loop(); como o nome já diz, vai servir para repetir a programação infinitamente até que se desligue o arduino. Mas na programação dentro do loop que o led vai ficar acesso por 1000 milissegundos

PS: No delay, que seria o tempo da função que foi ativado, é em milissegundos.

     Voltando, o led vai ficar acesso por 1 segundo e depois vai se desligar por 1 segundo e isso vai ficar assim o tempo todo até que desligue o arduino.

2-Programação em for:

     Nessa programação precisa colocar o led numa porta PWM que está marcado na placa do arduino, a programação vai ficar fica assim:

int led= 10;  //Declarei a variável 10 vai se chamar led, idem ao anterior

void setup()

{

  pinMode(led, OUTPUT); //Agora declarei que aquela porta 10 é a porta digital do arduino

}

void loop()

{

  for(int i = 0; i < 255; i++) //Condição que usei, i começa em zero, se ele for menor que 255 vai somar 1 para i

   {

     analogWrite(led, i); //Led acende de acordo com o valor de i

     delay(250); //Durante 250 milissegundos

   }

}

     Bom, eu mudei a porta e coloquei numa porta PWM, mas lembrando de que, declarei a variável 10 do led, no void setup() que , digamos, eu falei que seria na porta 10 do arduino.

     A grande mudança foi no loop(), que usei a sentaça for, dentro desse sentença como viram tem uma expressão, nessa função vocês tem que falar inicialização, condição e incremento.

     Então, i declarei dentro do for para ser uma variável qualquer, mas essa variável vai está ligado a corrente que vai passar no led. Comecei com a variável em 0 (inicialização); se i for menor que 255 (condição); vão ser somados 1 variável em i (incremento).

     Dessa vez não usei digitalWrite e sim analogWrite, que serve para as portas pwm... Agora vocês se perguntando o que seria essas portas pwm: É uma porta aonde você controla a corrente que passa onde que variável de 0-1023, mas na programação esse valor é divido por 4, logo vai variar de 0-255.

Atmel Studio

Para programar o Arduino não é necessário programar somente no IDE e sim em outros programas. Hoje vou ensinar a configurar o Atmel Studio 6 para programar no Arduino em Wiring (programação própria do IDE)... Para fazer o download do software que é gratuito é só entrar no site do Fabricante Atmel (é necessário fazer um registro para pode fazer o download), para quem não sabe os Atmegas são fabricados pela própria Atmel.

     Aprendi a usar o novo software pelos vídeo 1 e o vídeo 2 do Fernando Nunes. Percebi alguns pontos negativos para programar, para cada Arduino com porta diferente (COM 1, COM 2, etc.) é necessário configurar novamente; Para cada modelo de Arduino (UNO, MEGA, NANO, etc.) é necessário configurar novamente¹; Para cada versão de IDE (as vezes versões novas da erros com IDEs antigos, etc) é necessário configurar novamente²; Para cada programação que for fazer, sempre vai ter que configurar, não igual aos outros e sim direcionando aonde estão as bibliotecas do IDE³.

     Caso faça isso para uso pessoal e que não trabalhe com muitos Arduinos, vale a pena usar o software.

     Para começar iremos instalar uma extensão do Atmel Studio da janela Serial, para que possamos visualizar os valores dos sensores ou fazer controle pelo teclado, como se fosse o Monitor Serial do IDE.

Assim que abrir o programa vai em Tools -> Extension Manager -> Available Dowload (que fica no lado esquerdo da janela) -> Terminal Window.

Para fazer o download será necessário entrar com o seu login e a senha, o mesmo que registrou para fazer o download. Após feito o download e instalado, pronto já podemos ir para próxima etapa.

     Agora nessa etapa vamos configurar o AVR dude (configuração para programar o chip do Arduino). A partir de agora fica um pouco trabalhoso para configurar, isso só irá servir para programar um tipo, modelo de arduino.

     1.0 - Vai em Tools -> External Tools (serve para configurar uma nova ferramenta).

     1.1 - Após abrir uma janela vamos configurar cada item: Title: eu coloquei Upload Arduino UNO COM3 (isso porque era a versão do meu Arduino e a porta que está usando, mas vocês podem colocar outro nome).

     1.2 - Em Command: você vai direcionar o arquivo executável do avrdude, vamos achar nele na posta do Arduino: arduino -> hardware -> tools -> AVR -> bin -> avrdude.exe

     1.3 - Agora vai dar trabalho, em Arguments: 

     Para preencher esse campo vamos abrir o IDE do Arduino e ir em File -> Preference e vamos marca para começar só o upload e deixar desmarcado o compilation

     Após isso pegue uma programação de exemplo como blink e manda fazer o upload, isso sem nenhum arduino está conectado ao computador (lembrando que tem que ser com a porta que o seu arduino usa no computador e o modelo) com o erro você vai copiar a parte da imagem que está marcada e colar em Arguments:

     Após colocar esse endereço nos Arguments... Logo depois do :w: tem que escrever: "$(ProjectDir)Debug\$(ItemFileName).hex":i. Agora sim acabamos com esse item.

     1.4 - Só marcar agora o item Use Output Window e acabamos com essa primeira parte.

OBS.: Isso só serve para configurar para fazer a compilação de um TIPO e MODELO de Arduino.

Agora vamos configurar a Biblioteca do Arduino:

      2.0 - Primeiramente vamos criar uma pasta chamada de ArduinoCore (dentro vão ser salva a biblioteca dos pinos e de programação do IDE dentro da pasta do Atmel Studio (essa pasta é onde vão ser salvas as programações feitas por ele) que foi criada nos meus documentos logo que você instalou o software.

    2.0.1 - Em arduino -> hardware -> arduino -> cores -> arduino. Copia todos os arquivos com arquivos .h e cola no ArduinoCore, os arquivos C e C++ não copia.

    2.0.2 - Agora vamos salvar o arquivo .h que fala dos pinos do Arduino que fica emarduino -> hardware -> arduino -> variants -> Standard (isso se o seu for o UNO), caso você não saiba você vai na pasta arduino -> hardware -> arduino no arquivo boards.txt (vai aparecer um pouco bagunçado mas nesse arquivo você vai saber qual pasta que esta dentro de variants usar. Sabendo o arquivo você pega o arquivopins_arduino e cole em ArduinoCore.

     2.0.3 - Agora é o ultimo arquivo para salvar dentro dessa pasta. Agora no IDE em File -> Preference e vamos marca para começar só o compilation e deixar desmarcado o upload e com a programação de exemplo blink mandar fazer a compilação mas sem o arduino conectado ao computador, de novo vai dar erro.

     Essa mensagem é muito grande para agilizar, logo na primeira linha que tem a terminação do core.a seleciona o endereço marcado na imagem e cola no endereço do meu computador.

     Copie o arquivo core.a e cole no ArduinoCore, mas renomeie para libcore.a. Com isso terminamos a nossa pasta com os arquivos de ArduinoCore.

     Agora toda vez que for fazer a programação, terá que configurar a pasta para exibir a biblioteca de programação do wiring (não é a biblioteca como servo, display, etc.) mas para ir adiantando copie a pasta que está dentro do arduino Librares e cole dentro da pasta Atmel Studio junto com o ArduinoCore.

     Quando for criar a programação vamos em: Criar Novo Projeto e selecionaremos o terceiro item que é GCC C++ Executable Project e logo a segui o escolher o chip que usamos, no caso o UNO é o ATmega328p.

    Apos carregado a janela de programação vamos selecionar as bibliotecas emProject -> Nome da programação properties (ALT + F7) -> Toolchain.

     2.1 - Nos itens AVR/GNU C Copiler e AVR/GNU C++ Copiler será feita a mesmas coisas.

     2.1.1 - Em Directores vamos selecionar a pasta ArduinoCore

     Assim que escolher a pasta, ANTES de clicar em ok precisa desmarcar a opçãoRelative Path isso em todas as vezes que for selecionar a pasta do ArduinoCore.
     2.1.2 - Em Optimization em Optimization Level selecionar a ultima opção e marca o primeiro item... os três primeiros itens vão ficar marcados que nem a imagem a seguir.

     2.2 - Agora em AVR/GNU Linker em Optimization é só marcar a primeira opção (irão ter três, só a primeira que irá ficar marcado).

     2.2.1 - Em Libraries, no primeiro quadro ao adicionar a o item, escrevemoslibcore.a e logo em seguida ok. No seguindo quadro vamos adicionar a pasta ArduinoCore e também a pasta das bibliotecas do Arduino como tinha dito para adiantar anteriormente, mas fazendo o mesmo esquema, quando for selecionar a pasta precisa desmarcar a opção Relative Pach.

     Pronto terminamos de configurar tudo, agora e aperta o botão de salvar e voltar para a pagina de programação... Lá você apaga tudo que está escrito e sempre que for fazer a programação você vai escrever:

#define F_CPU 16000000

#define ARDUINO 101

#include "Aduino.h"

     E logo a seguir fazer a programação desejada, no vídeo mostro fazendo a programação do blink e do controle pelo teclado para mostrar também como funciona o Terminal Window.

     Após ter feito a programação para verificar se está funcionando você vai em Build -> Build Solution esse item que fará a verificação da programação, caso não tenha nenhum erro você vai em Tools -> Upload Arduino UNO (ou como você tenha nomeado anteriormente). Você verá que a programação será enviada com sucesso para a sua placa.

     Sempre que você programar, precisa escrever os comando como foi dito antes e logo em seguida escrever a programação normalmente como se fosse no IDE.

Vídeo:

Vídeo sendo editado, logo será exibido, desculpa pela falta do vídeo pessoal

    Espero que tenham entendido, também sou novo com o programa Atmel Studio... Qualquer duvida só falar.

sexta-feira, 12 de outubro de 2012

Diferença entre Arduinos

     Fala Pessoal... já tem um bom tempo que não posto nada mas estou voltando com tudo. Para voltar ao assunto, falar das diferenças das placas (dados técnicos deles e para qual projeto seriam ideal) geralmente mais usados.

Arduino UNO
(Existem várias versões de Arduino UNO como UNO SMD, UNO R2 e o último UNO R3)

Microcontrolador	ATmega328
Tensão de operação	5V
Tensão de entrada (recomendada)	7-12V
Tensão de entrada (limites)	6-20V
Pinos de I/O Digitais	14 (6 deles com saída PWM)
Pinos Analógicos	6
Corrente CC  por I/O Pino	40 mA
Corrente do Pino 3.3V	50 mA
Memória Flash	32 KB (ATmega328) 0.5 KB usado pelo bootloader
SRAM	2 KB (ATmega328)
EEPROM	1 KB (ATmega328)
Velocidade do Clock	16 MHz

     Ele é ideal para quem está começando com essa placa, muita gente que começa as vezes querem já fazendo projetos grandes ou pequenos para ver sua capacidade. Concerteza, caso o projeto não for muito elaborado e que precise usar todas as portas, acho um pouco difícil, esse é ótimos para os iniciantes e para quem já usa normalmente.
"Uno" significa um em italiano e é nomeado para marcar o lançamento do Arduino 1.0

Arduino MEGA
(Existem outras versões também como MEGA UNO, MEGA R3)

Microcontrolador	ATmega2560
Tensão de operação	5V
Tensão de entrada (recomendada)	7-12V
Tensão de entrada (limites)	6-20V
Pinos de I/O Digitais	54 (14 deles com saída PWM)
Pinos Analógicos	16
Corrente CC  por I/O Pino	40 mA
Corrente do Pino 3.3V	50 mA
Memória Flash	256 KB (ATmega2560) 8 KB usado pelo bootloader
SRAM	8 KB (ATmega2560)
EEPROM	4 KB (ATmega2560)
Velocidade do Clock	16 MHz

     Bom como podem ver esse Arduino possui bem mais portas, ótimo para projetos grandes que utilizariam muitas portas e também usar até os shields sem que atrapalhe no mesmo. Exemplo de projeto com isso é automatizar uma casa com ele, casa porta controlar um Relé para acionar as tomas, lâmpadas, etc.

Arduino ADK

Microcontrolador	ATmega2560
Tensão de operação	5V
Tensão de entrada (recomendada)	7-12V
Tensão de entrada (limites)	6-20V
Pinos de I/O Digitais	54 (14 deles com saída PWM)
Pinos Analógicos	16
Corrente CC  por I/O Pino	40 mA
Corrente do Pino 3.3V	50 mA
Memória Flash	256 KB (ATmega2560) 8 KB usado pelo bootloader
SRAM	8 KB (ATmega2560)
EEPROM	4 KB (ATmega2560)
Velocidade do Clock	16 MHz

     Como podemos ver, a unica diferença do ADK para o Arduino MEGA em si é que o ADK possui uma porta USB que serve para ligar em aparelhos que possua Android. Essa placa serve para projeto que tenha interação com o Android.

Arduino Leonardo

(Essa placa é a mais recente, foi criada a pouco tempo)

Microcontrolador	ATmega32U4
Tensão de operação	5V
Tensão de entrada (recomendada)	7-12V
Tensão de entrada (limites)	6-20V
Pinos de I/O Digitais	20 (7 deles com saída PWM)
Pinos Analógicos	12
Corrente CC  por I/O Pino	40 mA
Corrente do Pino 3.3V	50 mA
Memória Flash	32 KB (ATmega32U4) 4 KB usado pelo bootloader
SRAM	2,5 KB (ATmega32U4)
EEPROM	1 KB (ATmega2560)
Velocidade do Clock	16 MHz

     Essa placa é recente, creio que serve para quem já está acostumado com o Arduino pois na programação criaram mais funções com ele, como usar a placa como teclado ou mouse. Outra coisa que difere das outras placas é que o processamento dele é mais rápido 32U4 sendo que os outros são 8U2.

     Existem outros tipos como Fio, Nano, Pro Nano, LilyPad... Mas esses tipos de Arduinos são muito pequenos, perfeitos para projetos pequenos e que gostariam que fossem discretos... Mas podem saber mais no site do arduino.cc

Agora voltei e tem muito mais por vir... Até a próxima galera...

sábado, 21 de julho de 2012

Atualização do Blog

     Bom pessoal, primeiramente peço desculpas pela demora das postagens, pois no momento estou com pouco tempo para poder montar os projetos e para dificultar ainda mais, a câmera digital queimou e tem 4 postagens que estão sem vídeo e peço desculpas pelo buraco que está tendo nesses posts.

    Mas o foco dessa postagem é para divulgar que o Blog vai entrar numa atualização como está crescendo, vai possuir um domínio (.com ou .com.br) e tudo de certo abrirei uma Loja Virtual com materiais Eletrônicos, Robótica e Arduino.

     Estou com uma lista de projetos melhorados (dos projetos que já postei), pendentes que ainda não concluir e desenvolvendo projetos próprios para divulgar para vocês. Espero que entendam e continuem lendo, qualquer duvida irei ajudar o máximo possível.

Pretendo postar logo em breve... Até mais pessoal...

sexta-feira, 15 de junho de 2012

Sensor de Proximidade com Infravermelho

     Existem várias maneiras de fazer um projeto para detectar um obstáculo, como já tinha postado antes, um deles foi o sensor de toque. Nesse caso vou mostrar como se faz com sensor infravermelho que, funciona a mesma coisa que um sistema de sensor de luz.

     Bom, no circuito logo a seguir irão ver que possui 2 LEDs IR emissor e 1 LED IR receptor. Os dois emissores mandam a luz infravermelho, caso não tenha obstáculo a frente a luz não irá voltar com intensidade, caso tenha um obstáculo a frente a luz que foi emitida irá ser refletida e o receptor fará a leitura. Quando o obstáculo fica mais próximo, maior será o valor da leitura no Arduino.

Esquema:

Houve um erro na imagem a ordem fica: 5v, GND e Sinal

     Na programação vou usar um exemplo quando houver algum obstáculo, acenderá um LED. Bom que com esse projeto é bem semelhante ao sensores como Sharps que são bem carinhos.

Programação:

int sensor = 0;
int valor = 0;
int led = 13;
void setup()
{
  pinMode(led, OUTPUT);    //Especifiquei que LED é saída de dados
  Serial.begin(9600);      //Taxa de dados 9600 bps (bytes por segundo)
}
void loop()
{
  valor=analogRead(sensor);//Preparando o sensor, dizendo que a leitura pertence ao valor
  Serial.println(valor);   //Linha que expressa para mostrar o valor do sensor no Monitor Serial
  if(valor > 200)          //Condição que se o valor for maior que 200
  {
    digitalWrite(led, HIGH);//LED fica acesso
  }
  else                      //Caso contrario,
  {
    digitalWrite(led, LOW); //LED fica apagado
  }
}