Arduino no 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 em
arduino -> 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 arquivo
pins_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 em Project -
> 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ção

Relative 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, escrevemos libcore.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.
Postado por Eduardo Almeida às 20:20 1 comentários
Enviar por e-mail BlogThis! Compartilhar no Twitter Compartilhar no Facebook
Compartilhar no Orkut
Marcadores: Arduino, Programação

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...
Postado por Eduardo Almeida às 22:02 0 comentários
Enviar por e-mail BlogThis! Compartilhar no Twitter Compartilhar no Facebook
Compartilhar no Orkut
Marcadores: Arduino

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...

Postado por Eduardo Almeida às 16:20 0 comentários
Enviar por e-mail BlogThis! Compartilhar no Twitter Compartilhar no Facebook
Compartilhar no Orkut
Marcadores: Notícias

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
}
}

Vídeo:
O vídeo está sendo editado, mas logo será postado

Bom, espero que tenham gostado, qualquer duvida já sabem só comentar. Até mais...