Escolar Documentos
Profissional Documentos
Cultura Documentos
Tutorial Arduino
Tutorial Arduino
ESCOLA NAVAL
DEPARTAMENTO DE ENGENHEIROS NAVAIS
RAMO DE ARMAS E ELECTRNICA
Arduino
Introduo e Recursos Avanados
2009
ndice
1. Introduo ............................................................................................................................ 7
2. Hardware vs Software ......................................................................................................... 8
2.1. Hardware ...................................................................................................................... 8
2.1.1. Microprocessador ................................................................................................ 9
2.1.2. Microcontrolador ................................................................................................. 9
2.1.3. Tipos e Quantidades de Memria Disponveis ................................................ 11
2.1.4. Pinout Disponvel ............................................................................................... 12
2.2. Software ..................................................................................................................... 15
2.2.1. Instalao e Utilizao ...................................................................................... 15
2.2.2. Ciclo de Desenvolvimento ................................................................................ 17
2.2.3. Interaco do Arduino com outro Software .................................................... 18
3. ndice de Instrues ........................................................................................................... 18
3.1. Funes Base ............................................................................................................. 19
3.1.1 void setup()......................................................................................................... 19
3.1.2 void loop()........................................................................................................... 19
3.1.3. Resumindo ......................................................................................................... 20
3.2. Ciclos ........................................................................................................................... 21
3.2.1 Ciclo If.else .................................................................................................. 21
3.2.2 Ciclo for ............................................................................................................... 22
3.2.3 Ciclo switch / case .............................................................................................. 23
3.2.4 Ciclo while .......................................................................................................... 24
3.2.5 Ciclo do.while ................................................................................................. 25
3.3. Tipos de variveis disponveis .................................................................................. 26
3.3.1 Varivel do Tipo Boolean .................................................................................. 26
3.3.2. Varivel do tipo char vs unsigned char ............................................................. 27
3.3.3. Varivel do tipo byte ......................................................................................... 27
3.3.4. Varivel do tipo int vs unsigned int .................................................................. 28
3.3.5. Varivel do tipo long vs unsigned long ............................................................. 28
3.3.6. Varivel do tipo float vs double ........................................................................ 29
3.3.7. Varivel do Tipo array e a Noo de string ...................................................... 29
3.4. Converter tipos de variveis ..................................................................................... 30
3.4.1. char(x) ................................................................................................................. 30
3.4.2. byte(x) ................................................................................................................ 30
3.4.3. int(x).................................................................................................................... 30
3.4.4. long(x)................................................................................................................. 30
3.4.5. float(x) ................................................................................................................ 30
3.5. Funes....................................................................................................................... 31
3.5.1. Input/Output digital ............................................................................................... 31
3.5.1.1. pinMode() ....................................................................................................... 31
3.5.1.2 digitalWrite() ...................................................................................................... 32
3.5.1.3. digitalRead()................................................................................................... 33
3.5.2. Input/Output analgico ......................................................................................... 34
3.5.2.1 analogRead() ...................................................................................................... 34
3.5.2.2 analogWrite() ..................................................................................................... 35
3.5.3. Tempo ..................................................................................................................... 36
3.5.3.1. millis() ............................................................................................................. 36
3.5.3.2. micros() ........................................................................................................... 36
3.5.3.3. delay (milisegundos) ..................................................................................... 37
3.5.3.4. delayMicroseconds (microsegundos)........................................................... 37
3.5.4. Funes Matemticas ........................................................................................... 39
3.5.4.1. min(valor1,valor2) ......................................................................................... 39
3.5.4.2. max(valor1,valor2) ........................................................................................ 39
3.5.4.3. abs(valor) ........................................................................................................ 39
3.5.4.4. constrain(valor, valor1.,valor2) .................................................................... 40
3.5.4.5. map(X,valor1,valor2,para valor1,para valor2) ............................................ 40
3.5.4.6. pow(valor, expoente) .................................................................................... 41
3.5.4.7. sqrt(valor) ....................................................................................................... 41
3.5.5. Funes Trigonomtricas ..................................................................................... 42
3.5.5.1. sen(valor) ........................................................................................................ 42
3.5.5.2. cos(valor) ........................................................................................................ 42
3.5.5.1. tan(valor) ........................................................................................................ 42
3.5.6. Nmeros Aleatrios .............................................................................................. 43
3.5.6.1 randomSeed(valor) ............................................................................................ 43
3.5.6.2. random() ......................................................................................................... 43
3.5.7. Interrupts................................................................................................................ 45
3.5.7.1. attachInterrupt(interrupt, funo,modo) ................................................... 45
3.5.7.2. detachInterrupt(interrupt)............................................................................ 46
5. Concluso ........................................................................................................................... 68
6. Bibliografia ......................................................................................................................... 69
1. Introduo
Este tutorial tem como principal objectivo ser uma referncia para a utilizao da placa
de desenvolvimento Arduino, no s para quem se est a iniciar no assunto, mas, tambm,
para quem procura aprofundar mais o seu conhecimento sobre o tema.
O Arduino uma ferramenta de desenvolvimento open source, tendo surgido de um
projecto acadmico - quem sabe um projecto seu no poder ter o mesmo sucesso?... Como
ferramenta usualmente associado filosofia de Physical Computing, ou seja, ao conceito
que engloba a criao de sistemas fsicos atravs do uso de Software e Hardware capazes de
responder a inputs vindos do mundo real.
Podemos designar o Arduino simplesmente como uma pea de Hardware ou um
Software de desenvolvimento, mas muito mais que isso. Devido ao sucesso que tem vindo a
alcanar ao longo do tempo, existe uma enorme comunidade de utilizadores/seguidores em
todo o Mundo, podendo afirmar-se que o Arduino representa tambm uma enorme
comunidade. As razes para tal sucesso baseiam-se no seu baixo custo - dadas as suas
funcionalidades -, a simplicidade na utilizao e a possibilidade de utilizao em vrios
sistemas operativo, como o Windows, Macintosh OS e Linux - capacidade essa denominada
por Cross-platform.
O estudo do Arduino abre-nos portas compreenso de uma importante ferramenta de
desenvolvimento atravs de uma aprendizagem simples mas dedicada, onde podemos fazer
desde robots a domtica entre muitas outras aplicaes, bastando simplesmente ter
imaginao.
Devido sua enorme utilizao, como foi referido anteriormente, torna-se um assunto
quase que obrigatrio a abordar, sendo o seu conhecimento uma mais-valia para todos os
interessados pela electrnica (e no s).
Assim, espera-se que este tutorial seja uma pequena ajuda para a aquisio de
conhecimento sobre a temtica em estudo, que dever pautar pela dedicao.
2. Hardware vs Software
Antes de comear a trabalhar propriamente com esta plataforma de desenvolvimento,
torna-se necessrio comear por perceber o seu funcionamento, para tal descrever-se- neste
captulo o funcionamento do Arduino, em termos de Hardware e Software.
Espera-se assim de certa forma iluminar o caminho neste estudo, fazendo com que
toda a percepo do assunto a tratar se torne mais simples, ou seja, sero aqui apresentadas
as bases para a sua compreenso.
2.1. Hardware
De seguida, far-se- uma exposio do tema incidindo na placa Arduino Duemilinove
(disponvel na Escola Naval -EN), em tudo semelhante em termos de utilizao placa de
desenvolvimento Arduino Mega. Contudo verificam-se pequenas diferenas como a diferena
na sua capacidade de armazenamento (memria disponvel), o nmero de pinos analgicos, o
nmero de pinos digitais e as dimenses.
O Arduino Duemilinove (Fig. 1) apresenta-se com o microcontrolador ATMega168 ou
ATMega328, enquanto o Arduino Mega (Fig.2) apresenta-se com um microcontrolador
ATMega1280.
2.1.1. Microprocessador
Um microprocessador, basicamente, constitudo por um circuito integrado com a
capacidade de executar determinadas instrues, sendo a sua velocidade de processamento
determinada por um circuito que produz um determinado Clock (kHz, MHz ou GHz).
O seu poder de processamento afectado por caractersticas como Bits, quantidade de
ncleos, arquitectura apresentada, tipo de instrues, entre outras. Como factor de grande
importncia tem-se ainda a existncia de memria externa, onde esto armazenados os
programas que sero executados.
Microprocessador
Perifricos
Clock
2.1.2. Microcontrolador
Um microcontrolador, ao contrrio de um microprocessador, desenhado e construdo
de forma a integrar diversos componentes num nico circuito integrado, evitando, assim, a
necessidade de adicionar componentes externos ao microcontrolador, que permitiriam as
suas funcionalidades.
Etc Etc
CPU ROM Porta Srie
Pela anlise da figura acima, pode-se ter uma noo de alguns exemplos de
componentes que se encontram disponveis, conseguindo reunir uma grande quantidade de
recursos num nico circuito integrado.
Na figura seguinte, apresentado um diagrama de blocos de um microcontrolador
ATMega168 em tudo idntico a um ATMega328 em que possvel identificar todos os
seus constituintes.
Como podemos constatar pela anlise da tabela 1, o ATMega1280 leva clara vantagem
em termos de capacidade. Uma das memrias mais importantes, alm da memria Flash
que permite o armazenamento do bootloader e do programa sketch - a ser executado, a
memria SRAM (Static Random Access Memory), que se comporta de forma semelhante
RAM nos nossos computadores. na SRAM que o programa, ao ser executado, cria e modifica
todo o tipo de variveis necessrias sua execuo. Este tipo de memria apenas mantm os
dados enquanto se encontra alimentada, o mesmo no acontece com a memria EEPROM
(Electrically-Erasable Programmable Read-Only Memory) e memria Flash.
A memria Flash nos dias de hoje comummente utilizada em cartes de memria,
pendrives, memria de armazenamento em cmaras de vdeo, telemveis, PDA (Personal
Digital Assistant), entre muitas outras aplicaes. Podemos resumir o tipo de memria, em
funo da sua utilizao, da seguinte forma:
Com vista a ser poupada memria SRAM, necessria para a correcta execuo do
programa, por vezes so guardadas constantes (p.ex. o nmero ) na memria Flash e
EEPROM. Para tal, recorrem-se a bibliotecas prprias que possibilitam essa leitura e escrita,
para a EEPROM pode-se recorrer { biblioteca <EEPROM.h> e para a memria Flash pode-se
recorrer biblioteca <pgmspace.h> ou <Flash.h>.
Neste tutorial apenas vo ser abordadas a biblioteca <EEPROM.h> e <Flash.h>,
mas, devido ao carcter open source, existem muitas outras bibliotecas disponveis para as
mesmas finalidades, devendo o leitor procurar trabalhar com a que se sente mais vontade e
obtm os melhores resultados. A abordagem a estas duas bibliotecas encontra-se no captulo
4 Recursos Avanados.
14
Pinos de I/O digitais
(6 com Pulse Width Modulation (PWM))
Pinos analgicos 6
Pinos de Ground (GND) 3
Pinos de 5 V 1
Pinos de 3.3 V 1
Pinos de Analog Reference (AREF) 1
Pinos de reset (RESET) 1
Tabela 2 Pinout disponvel (Arduino Duemilinove)
ainda importante referir que a corrente mxima por cada pino analgico e digital de
40 mA, excepo da sada que providencia 3.3 V (visvel na figura 1 e figura 5), que permite
correntes mximas de 50 mA.
De acordo com Sousa and Lavinia, 2006, a capacidade de utilizar Pulse Width
Modulation (PWM), muito importante, pois permite obter uma tenso analgica a partir de
um sinal digital, ou seja, de um sinal que apenas pode assumir o estado lgico 0 (0V) ou 1 (5
V). O conceito de PWM utilizado para referir sinal que possua uma frequncia constante e
um duty cicle vari|vel.
A teoria por detr|s deste fenmeno pode ser facilmente descrita. Analisemos a
seguinte equao:
1
=
0
0
=
0 <
Nota: Na equa~o anterior representa a dura~o do impulso, e representa
a tenso do impulso do sinal PWM.
= + 0
0
Ficando pois:
=
Podemos concluir, pela an|lise da equa~o anterior, que a tens~o mdia ( ")
directamente proporcional ao duty cicle do sinal PWM. Esta caracterstica permite-nos fazer
variar a tenso, neste caso especfico, variar a tenso entre 0 e 5 V (Arduino).
Aps uma breve descrio sobre o modo de funcionamento de um sinal PWM, vamos
agora aprofundar um pouco mais a converso A/D. Este factor de grande interesse e a sua
compreenso fundamental para perceber os valores obtidos nos pinos analgicos. O
microcontrolador utilizado possui um conversor analgico digital de 10 bits, fazendo as
contas:
210 = 1024
Como a tenso mxima de referncia, por definio, se encontra nos 5V,
correspondendo ao valor 1023, obtemos a seguinte resoluo:
5 1024 0,00488 V 5 mV
2 1024 1.953 mV 2 mV
importante ter em conta que todos os pinos analgicos ficam com esta referncia,
sendo necessria tambm a sua declarao por Software pela forma
analogReference(tipo). A referncia analgica pode, assim, ser de trs tipos:
2.2. Software
2.2.1. Instalao e Utilizao
Neste captulo, vai ser efectuada uma breve descrio de como instalar e utilizar o
Software de desenvolvimento Arduino.
O Software de desenvolvimento Arduino bastante fcil e intuitivo de utilizar, no
havendo qualquer nvel de dificuldade. Foram estruturados passos de forma a simplificar a sua
utilizao e instalao.
1- O 1 passo consiste em efectuar o download do respectivo software de
desenvolvimento, atravs do site oficial Arduino (www.arduino.cc).
A ltima verso disponvel aparecer na parte superior da pgina, como mostra a figura
abaixo, sendo s necessrio escolher a verso apropriada para o sistema operativo que nos
encontramos a trabalhar. Actualmente, a verso mais actual a 0016, mas quando estiver a
ler este tutorial muito provavelmente j deve haver uma verso mais avanada.
Opo Tools
Fig.14 Boto para compilar o Sketch elaborado Fig.15 Boto para efectuar uploading
3. ndice de Instrues
Neste captulo, vo ser referidas as mais importantes instrues base do ambiente de
desenvolvimento Arduino, sem recorrer a bibliotecas externas, sendo estas enumeradas por
tipo de aplicao. Antes de abordar algumas das instrues possveis numa linguagem de alto
nvel, podemos fazer uma breve abordagem para analisar qual a classificao a atribuir ao
microcontrolador em estudo.
De acordo com Arroz, Monteiro et al. 2007, pg. 732, podemos classificar os
processadores tendo em conta o seu conjunto de instrues em duas categorias:
CISC (Complex Instruction Set Computers)
RISC (Reduced Instruction Set Computers)
Baseando-se a arquitectura CISC num conjunto de instrues com modos de
endereamento bastante complexos, ao utilizar este tipo de arquitectura permitido elaborar
programas bastante compactos e codificveis ao recorrer a um uso reduzido de instrues.
Alguns dos inconvenientes deste tipo de arquitectura so baseados no elevado tempo de
ciclos de relgio, necessrios para executar cada uma das suas instrues. Outro
inconveniente a existncia de variados modos de endereamento.
Por outro lado os processadores baseados em arquitecturas do tipo RISC, apresentam
um conjunto de instrues bastante reduzido, possibilitando assim obter uma enorme
simplicidade e um tempo de execuo menor por instruo que a arquitectura CISC.
Conseguindo, assim, com um conjunto de instrues bsicas com tempo de execuo
menores, obter, no final, velocidades de processamento mais elevadas que a arquitectura
CISC.
Na sua verso mais simples, baseando a anlise em Arroz, Monteiro et al. 2007 pg.
733, pode afirmar-se que os processadores RISC possuem os seguintes tipos de instrues:
Instrues lgicas e aritmticas sobre registos;
Instrues de transferncia de dados entre memria e registos;
Instrues de controlo.
No datasheet dos microcontroladores utilizados nos modelos do Arduino, pode-se
perceber que estamos perante microcontroladores baseados numa arquitectura advanced
RISC. Segundo Tecnology 1992 pg. 14, em que efectuado uma reviso completa
arquitectura advanced RISC, referido que esta arquitectura foi desenvolvida para ser uma
especifica~o standard para uma famlia de microprocessadores baseada na famlia MIPS.
Exemplo:
(1) int botao=3; // Declarao de uma varivel do tipo integer, com o nome botao
inicializada com o valor 3.
(2) void setup() {
(3) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(4) pinMode(botao,INPUT); // Permite definir o pino 3 como INPUT
(5) }
(6) void loop(){
(7) (.)
(8) }
Exemplo:
(1) int botao=3,val; // Declarao de uma varivel do tipo integer, com o nome
botao inicializada com o valor 3 e de uma varivel do mesmo tipo com o nome
val
(2) void setup() {
(3) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(4) pinMode(botao,INPUT); // Permite definir o pino 3 como INPUT
(5) pinMode(13,OUTPUT); // Permite definir o pino 13 como OUTPUT
(6) }
(7) void loop(){
(8) val=analogRead(botao); // Permite a leitura analgica do valor do pino 3
atribuindo o seu valor varivel val
(9) if(val>=500){ // Ciclo if que testa a condio val>=500 (maior ou igual a 500)
3.1.3. Resumindo
As funes void setup()e void loop() s~o de carcter obrigatrio, ou seja,
mesmo que no necessria a sua utilizao devero constar no cdigo utilizado.
E apenas ser~o chamadas funes externas que constem na fun~o void
loop().
Um resumo dos subcaptulos anteriores encontra-se expresso no exemplo
seguinte:
Exemplo:
3.2. Ciclos
3.2.1 Ciclo If.else
Descrio: utilizado para descrever uma condio, ou seja, quando uma
varivel for: igual, maior, menor ou diferente (de acordo com a declarao
efectuada) que um determinado valor executada uma determinada condio.
Podem-se usar vrios ciclos if.else encadeados, de forma a verificar diversas
condies.
Sintaxe:
if(condio){
Instruo 1;
Instruo 2;
(..)
}
else{
Instruo 3;
Instruo 4;
(..)
}
if(condio){
Instruo 1;
Instruo 2;
(..)
}
X == Y X igual a Y
X diferente de Y (no igual)
X != Y
X maior que Y
X>Y
X maior ou igual a Y
X >= Y
X menor que Y
X<Y
X menor ou igual a Y
X <= Y
Tabela 4 Condies possveis
Exemplo:
(1) int botao=3,val; // Declarao de uma varivel do tipo integer, com o nome
botao inicializada com o valor 3 e de uma varivel do mesmo tipo com o nome
val
(2) void setup() {
(3) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(4) pinMode(botao,INPUT); // Permite definir o pino 3 como INPUT
Sintaxe:
A inicializao apenas efectuada uma vez, no incio do ciclo. Cada vez que o
ciclo efectuado a condio testada. Caso a condio se verifique efectuado
o incremento, caso a condio no se verifique o ciclo termina a sua execuo. A
condio, referida anteriormente, declarada semelhana da condio
utilizada no ciclo if. O exemplo abaixo mostra um exemplo de implementao
do ciclo for, face s regras expostas acima.
Exemplo:
(9) f[i]=val; //Atribui o valor da varivel val ao vector f[i], ou seja, permite
preencher o vector com 11 valores do pino analgico 3
(10) }
(11) }
Sintaxe:
switch(varivel){
case 1:
Instruo a executar quando varivel for 1 (varivel == 1)
break;
case 2:
Instruo a executar quando varivel for 2 (varivel == 2)
break;
(..)
default:
Conjunto de instrues a executar se nenhuma das condies for verificada. A
utilizao desta condio opcional.
break;
}
Exemplo:
Sintaxe:
while(condio){
Instruo 1;
Instruo 2;
(..)
}
necessrio fazer com que a condio se torne falsa, caso se queira finalizar o
ciclo para executar outras instrues. Pois caso contrrio o ciclo vai ser
executado indefinidamente.
Exemplo:
Sintaxe:
do{
Instruo 1;
Instruo 2;
(..)
}
while(condio);
Exemplo:
Sintaxe:
Exemplo:
Sintaxe:
Exemplos:
Sintaxe:
Exemplos:
Sintaxe:
Exemplos:
Sintaxe:
Exemplos:
Sintaxe:
Exemplos:
Sintaxe:
Exemplos:
Descrio: Converte um valor de x, que pode ser de qualquer tipo, para uma
varivel do tipo char.
Sintaxe:
3.4.2. byte(x)
Descrio: Converte um valor de x, que pode ser de qualquer tipo, para uma
varivel do tipo byte.
Sintaxe:
3.4.3. int(x)
Descrio: Converte um valor de x, que pode ser de qualquer tipo, para uma
varivel do tipo integer.
Sintaxe:
3.4.4. long(x)
Descrio: Converte um valor de x, que pode ser de qualquer tipo, para uma
varivel do tipo long.
Sintaxe:
3.4.5. float(x)
Descrio: Converte um valor de x, que pode ser de qualquer tipo, para uma
varivel do tipo float.
Sintaxe:
3.5. Funes
Sintaxe:
Exemplo:
(1) int botao=3,val; // Declarao de uma varivel do tipo integer, com o nome
botao inicializada com o valor 3 e de uma varivel do mesmo tipo com o nome
val no inicializada com nenhum valor
(2) void setup() {
(3) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(4) pinMode(botao,INPUT); // Permite definir o pino 3 como INPUT
(5) pinMode(13,OUTPUT); // Permite definir o pino 13 como OUTPUT
(6) }
(7) void loop(){
(8) val=analogRead(botao); // Permite a leitura analgica do valor do pino 3
atribuindo o seu valor varivel val
(9) if(val>=500) // Ciclo if que testa a condio val>=500 (maior ou igual a 500)
(10) digitalWrite(13,HIGH); // Se a condio for verificada, atribudo ao pino
digital 13 a condio HIGH (5 V)
(11) }
(12) }
3.5.1.2 digitalWrite()
Descrio: Possibilita, nos pinos configurados como output atravs da instruo
pinMode, estabelecer a sada dos respectivos pinos com o valor lgico 1
(HIGH 5 V) ou com o valor lgico 0 (LOW 0V)
Sintaxe:
Exemplo:
(1) int botao=3,val; // Declarao de uma varivel do tipo integer, com o nome
botao inicializada com o valor 3 e de uma varivel do mesmo tipo com o nome
val no inicializada com nenhum valor
(2) void setup() {
(3) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(4) pinMode(botao,INPUT); // Permite definir o pino 3 como INPUT
(5) pinMode(13,OUTPUT); // Permite definir o pino 13 como OUTPUT
(6) }
(7) void loop(){
(8) val=analogRead(botao); // Permite a leitura analgica do valor do pino 3
atribuindo o seu valor varivel val
(9) if(val>=500) // Ciclo if que testa a condio val>=500 (maior ou igual a 500)
(10) digitalWrite(13,HIGH); // Se a condio for verificada, atribudo ao pino
digital 13 a condio HIGH (5 V)
(11) }
(12) }
3.5.1.3. digitalRead()
Descrio: Possibilita a leitura de uma entrada digital especfica, retornando um
valor no formato integer (int). Se obtivermos um valor de retorno de 1,
estamos perante uma leitura do tipo HIGH (valor lgico 1). Se tal no se
verificar, e tivermos um valor de retorno igual a 0, estamos perante uma
leitura do tipo LOW (valor lgico 0).
Sintaxe:
Exemplo:
(1) int botao=3,val; // Declarao de uma varivel do tipo integer, com o nome
botao inicializada com o valor 3 e de uma varivel do mesmo tipo com o nome
val no inicializada com nenhum valor
(2) void setup() {
(3) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(4) pinMode(botao,INPUT); // Permite definir o pino 3 como INPUT
(5) pinMode(13,OUTPUT); // Permite definir o pino 13 como OUTPUT
(6) }
(7) void loop(){
(8) val=digitalRead(botao); // Permite a leitura do valor do pino 3 digital
atribuindo o seu valor varivel val
(9) if(val==1) // Ciclo if que testa a condio val>=500 (maior ou igual a 500)
(10) digitalWrite(13,HIGH); // Se a condio for verificada, atribudo ao pino
digital 13 a condio HIGH (5 V)
(11) }
(12) else{ // Caso a condio do ciclo if no se verifique
(13) digitalWrite(13,LOW); // Se a condio no for verificada, atribudo ao pino
digital 13 a condio LOW (0 V)
(14) }
(15) }
Sintaxe:
Exemplo:
(1) int botao=3,val; // Declarao de uma varivel do tipo integer, com o nome
botao inicializada com o valor 3 e de uma varivel do mesmo tipo com o nome
val no inicializada com nenhum valor
(2) void setup() {
(3) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(4) pinMode(botao,INPUT); // Permite definir o pino 3 como INPUT
(5) pinMode(13,OUTPUT); // Permite definir o pino 13 como OUTPUT
(6) }
(7) void loop(){
(8) val=analogRead(botao); // Permite a leitura analgica do valor do pino 3
atribuindo o seu valor varivel val
(9) if(val>=500) // Ciclo if que testa a condio val>=500 (maior ou igual a 500)
(10) digitalWrite(13,HIGH); // Se a condio for verificada, atribudo ao pino
digital 13 a condio HIGH (5 V)
(11) }
(12) }
3.5.2.2 analogWrite()
Descrio: Possibilita a utilizao dos pinos PWM (Pulse Width Modulation) da
placa Arduino. O sinal PWM mantm-se at ser modificado atravs de uma
outra instruo que afecte esse pino, a frequncia do sinal PWM criado de
490 .
Sintaxe:
Exemplo:
(1) int botao=3,val; // Declarao de uma varivel do tipo integer, com o nome
botao inicializada com o valor 3 e de uma varivel do mesmo tipo com o nome
val no inicializada com nenhum valor
(2) void setup() {
(3) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(4) pinMode(botao,INPUT); // Permite definir o pino 3 como INPUT
(5) pinMode(13,OUTPUT); // Permite definir o pino 13 como OUTPUT
(6) }
(7) void loop(){
(8) val=analogRead(botao); // Permite a leitura analgica do valor do pino 3
atribuindo o seu valor varivel val
(9) if(val>=500) // Ciclo if que testa a condio val>=500 (maior ou igual a 500)
(10) analogWrite(9,255); // Instruo com a mesma funo que
digitalWrite(9,HIGH)
(11) }
(12) else{
(13) analogWrite(9,0); // Instruo com a mesma funo que
digitalWrite(9,LOW)
(14) }
(15) }
3.5.3. Tempo
3.5.3.1. millis()
Descrio: Possibilita o retorno da quantidade de tempo, em milisegundos na
forma de uma vari|vel do tipo unsigned long. O valor retornado representa o
tempo que, passou desde que o programa actual comeou a ser executado. O
overflow (voltar ao incio, valor zero) do contador ocorre passado um tempo de
50 dias.
Sintaxe:
Exemplo:
(1) unsigned long tempo; // Declarada uma varivel do tipo unsigned long com o
nome tempo
(2) void setup() {
(3) (..)
(4) }
(5) void loop(){
(6) tempo = millis(); // Atribui varivel tempo o valor em milisegundos desde
que o sketch actual comeou a ser executado
(7) }
3.5.3.2. micros()
Descrio: Possibilita o retorno da quantidade de tempo, em microsegundos na
forma de uma vari|vel do tipo unsigned long. O valor retornado representa o
tempo que, passou desde que o programa actual comeou a ser executado. O
overflow (voltar ao incio, valor zero) do contador ocorre passado um tempo de
70 minutos.
Sintaxe:
Exemplo:
(1) unsigned long tempo; // Declarada uma varivel do tipo unsigned long com o
nome tempo
(2) void setup() {
(3) (..)
(4) }
(5) void loop(){
(6) tempo = micros(); // Atribui varivel tempo o valor em microsegundos
desde que o sketch actual comeou a ser executado
(7) }
Sintaxe:
Exemplo:
(1) int led_pin=13; // Declarao de uma varivel do tipo integer com o nome
led_pin, sendo-lhe atribuda o valor 13
(2) void setup() {
(4) pinMode(led_pin,OUTPUT); // Permite definir o pino 13 como OUTPUT
(5) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(6) }
(7) void loop(){
(8) digitalWrite(led_pin,HIGH); // atribudo ao pino digital 13 a condio HIGH
(5 V)
(9) delay(200); // efectuado um delay de 200 ms, antes de efectuar a prxima
instruo
(10) digitalWrite(led_pin,LOW); // atribudo ao pino digital 13 a condio LOW
(0 V)
(11) delay(600); // efectuado um delay de 600 ms, antes de efectuar a prxima
instruo, neste caso a funo void loop() recomea
(12) }
Sintaxe:
Exemplo:
(1) int led_pin=13; // Declarao de uma varivel do tipo integer com o nome
led_pin, sendo-lhe atribuda o valor 13
(2) void setup() {
(4) pinMode(led_pin,OUTPUT); // Permite definir o pino 13 como OUTPUT
(5) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(6) }
(7) void loop(){
(8) digitalWrite(led_pin,HIGH); // atribudo ao pino digital 13 a condio HIGH
(5 V)
Sintaxe:
Exemplo:
3.5.4.2. max(valor1,valor2)
Descrio: Instruo que retorna o maior de dois valores.
Sintaxe:
Exemplo:
3.5.4.3. abs(valor)
Descrio: Instruo que retorna o modulo de um nmero.
Sintaxe:
Mdulo = abs(valor);
valor valor 0
Mdulo =
valor valor < 0
Exemplo:
int modulo=0;
modulo = abs(-5) // O valor atribudo varivel modulo seria o valor 5
Sintaxe:
Exemplo:
Sintaxe:
Valor num novo intervalo = map(Valor, valor1, valor2, Para valor1, Para valor2);
Exemplo:
Sintaxe:
Exemplo:
int valor=0;
valor = pow(2,2) // O valor atribudo varivel valor seria o valor 4, pois
22 = 4.
3.5.4.7. sqrt(valor)
Descrio: Permite o clculo da raiz quadrado de um determinado valor.
Sintaxe:
Exemplo:
int valor=0;
valor = sqrt(9) // O valor atribudo varivel valor seria o valor 3, pois 9 = 3.
Sintaxe:
Com Resultado 1; 1
3.5.5.2. cos(valor)
Descrio: Instruo que retorna o clculo do coseno, de um valor em radianos.
Sintaxe:
Com Resultado 1; 1
3.5.5.1. tan(valor)
Descrio: Instruo que retorna o clculo da tangente, de um valor em
radianos.
Sintaxe:
Com Resultado ; +
Sintaxe:
randomSeed(Valor);
Exemplo:
3.5.6.2. random()
Descrio: Instruo que permite gerar nmeros aleatrios (ou melhor
escrevendo - pseudo-aleatrios).
Sintaxe:
Exemplo:
3.5.7. Interrupts
3.5.7.1. attachInterrupt(interrupt, funo,modo)
Descrio: Instruo que permite definir o funcionamento de interrupts
externos. Ocorrendo a definio atravs desta instruo da funo a executar,
do pino onde vai ocorrer o interrupt e o modo como se deve responder
variao do sinal de entrada no pino a considerar.
Sintaxe:
3.5.7.2. detachInterrupt(interrupt)
Descrio: Possibilita desabilitar um interrupt previamente estabelecido
utilizando a instru~o attachInterupt().
Sintaxe:
detachInterrupt(interrupt);
3.5.7.3. interrupts()
Descrio: Instruo que permite voltar a activar o uso de interrupes, depois
de esta funcionalidade ter sido desactivada. O uso de interrupts encontra-se por
defeito activado.
Sintaxe:
interrupts();
Exemplo:
3.5.7.4. noInterrupts()
Descrio: Instruo que permite desactivar o uso de interrupes. O uso de
interrupts encontra-se por defeito activado.
Sintaxe:
noInterrupts();
Exemplo:
(3) }
(4) void loop(){
(5) noInterrupts(); // Instruo que desactiva o uso de interrupts
(6) Instruo 1;
(7) (..)
(8) interrupts(); // Instruo que activa o uso de interrupts
(9) (..)
(10) }
Sintaxe:
Exemplo:
(1) int leitura_serie=0; //Declarao de uma varivel do tipo integer com o nome
leitura_serie, inicializada com o valor 0
(2) void setup() {
(3) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(4) }
(5) void loop(){
(6) if(Serial.available()>0) // Condio if que verifica se esto a ser recebidos dados
por Srie
(7) leitura_serie=Serial.read(); // Caso se estejam a receber dados por srie, o seu
valor guardado na varivel integer leitura_serie
(8) }
(9) }
Exemplo:
(1) int leitura_serie=0; //Declarao de uma varivel do tipo integer com o nome
leitura_serie, inicializada com o valor 0
(2) void setup() {
(3) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(4) }
(5) void loop(){
(6) if(Serial.available()>0) // Condio if que verifica se esto a ser recebidos dados
por Srie
(7) leitura_serie=Serial.read(); // Caso se estejam a receber dados por srie, o seu
valor guardado na varivel integer leitura_serie
(8) }
(9) }
3.5.8.3. Serial.read()
Descrio: Permite a leitura dos dados recebidos por srie. Esta funo retorna
o valor -1 se no houver dados disponveis.
Sintaxe:
Exemplo:
(1) int leitura_serie=0; ; //Declarao de uma varivel do tipo integer com o nome
leitura_serie, inicializada com o valor 0
(2) void setup() {
(3) Serial.begin(9600); // Permite a inicializao da comunicao Srie
(4) }
(5) void loop(){
(6) if(Serial.available()>0) ) // Condio if que verifica se esto a ser recebidos
dados por Srie
(7) leitura_serie=Serial.read(); // Caso se estejam a receber dados por srie, o seu
valor guardado na varivel integer leitura_serie
(8) }
(9) }
3.5.8.4. Serial.flush()
Descrio: Efectua o flush (apaga) de todos os dados presentes no buffer de
entrada no momento de execuo da instruo. O buffer de entrada tem uma
capacidade de armazenamento de 64 bytes.
Sintaxe:
Serial.flush();
Exemplo:
Descrio: Instruo que permite o envio de dados pela porta srie. A nica
diferena entre Serial.print e Serial.println() que a segunda instru~o
adiciona ao dado enviado o caracter \r (carriage return) e o caracter \n
(new line).
Sintaxe:
Serial.print(dado a enviar);
Serial.print(dado a enviar, formato);
O formato de envio pode ser decimal (DEC), hexadecimal (HEX), octal (OCT) ou
binrio (BIN). O dado a enviar tambm pode tomar o formato de uma string.
Exemplo:
3.5.8.1. Serial.write()
Descrio: Permite enviar dados em binrio pela porta srie. Esses dados
podem ser enviados como um nico byte ou um conjunto de bytes.
Sintaxe:
Serial.write(valor);
Serial.write(string);
Serial.write(vector, comprimento);
A vari|vel valor acima define o valor a ser enviado em bin|rio pela porta srie,
o mesmo pode ser efectuado enviando uma string como um conjunto de
bytes. Na ltima instruo apresentada acima, enviado um vector (vector)
de tamanho comprimento.
4. Recursos Avanados
Este captulo tem como objectivo explorar algumas bibliotecas existentes para a
plataforma de desenvolvimento Arduino, possibilitando assim expandir as suas possibilidades.
As bibliotecas a ser expostas neste captulo so as mais usadas nos projectos de
desenvolvimento, mas no representam a totalidade das bibliotecas existentes. Ser tambm
aprofundado neste captulo a tem|tica taxa de amostragem no nosso contexto de estudo,
tentando que a sua compreenso se torne maior.
4.1. Flash
A quantidade de memria SRAM disponvel normalmente muito mais pequena do que
a memria flash disponvel e em programas em que necessrio recorrer utilizao de
muitas variveis facilmente a memria disponvel se torna uma limitao. Uma soluo bvia,
tendo em conta o que foi referido anteriormente, seria gravar o valor de algumas variveis em
flash. Mas existe uma limitao, na medida que a gravao de dados na memria flash apenas
pode ser efectuada quando o programa se encontra a ser carregado (durante o uploading)
para a memria flash. O que leva a que apenas os valores de variveis constantes devam ser
armazenados na memria flash, sendo utilizadas s quando necessrio (no se encontrando j
a ocupar espao em SRAM).
Para utilizar esta funcionalidade vais ser utilizada a biblioteca <Flash.h>, devendo a
mesma ser declarada no nosso sketch, esta biblioteca no se encontra disponvel no software
de desenvolvimento devendo o seu download ser efectuado do site Arduiniana
(http://arduiniana.org/libraries/flash/). Esta biblioteca baseia-se na biblioteca
<avr/progmen.h>, tentado simplificar assim o seu uso.
Existe mais sintaxe possvel por parte desta biblioteca, mas sem dvida foi aqui
apresentado o mais importante (Guardar e ler). Para mais informaes pode ser
consultado o site oficial desta biblioteca, j referido anteriormente.
4.2. EEPROM
O microcontrolador disponvel na placa de desenvolvimento Arduino Duemilinove
(ATMega168) possui 512 bytes de memria EEPROM, segundo o datasheet do respectivo
microcontrolador.
Este tipo de memria tem a vantagem de manter a sua informao armazenada,
mesmo aps desligarmos a sua alimentao, visto que pode ser de grande importncia
conseguir manter certos dados, dependo da aplicao a implementar. Uma outra vantagem
a possibilidade de guardar contedo nesta memria enquanto executamos o nosso sketch, o
que no acontece com o armazenamento em flash. Esta biblioteca j se encontra disponvel
no Software de desenvolvimento Arduino, no necessitando de ser adicionada.
A principal limitao da memria EEPROM est na existncia de um limite de ciclos de
leitura/escrita. O que pode ser uma limitao a curto prazo em aplicaes que recorram muito
a este tipo de armazenamento (este tipo de informao encontra-se discriminada no
datasheet do microcontrolador). O tempo de escrita num ATMega168 de 3.3 ms
(informao retirada do seu datasheet).
Exemplo:
4.3. Servomotor
Um servomotor um pequeno dispositivo cujo veio pode ser posicionado numa
determinada posio angular de acordo com um sinal de entrada. Enquanto esse sinal se
mantiver constante e for enviado para o servomotor, o servo ir manter a sua posio angular.
Ao variar o sinal de entrada possibilita uma variao a posio angular do veio. Os
servomotores so muito usados no controlo de avies telecomandados, robots, barcos
telecomandados, helicpteros telecomandados, entre outras possveis aplicaes.
Um servomotor, como se pode ver na figura 19, possui trs entradas. Uma entrada a
alimentao (normalmente 5V para servomotores standard), outra ser a massa e a ltima
que falta referir ser o sinal de entrada. Este sinal de entrada ser um impulso PWM, em que
fazendo variar o seu duty cicle, podemos variar a posio angular do servomotor. Isto em
servomotores de posio, pois tambm existem servomotores de rotao contnua. Nesses
servomotores a varia~o do duty cicle far| variar n~o a posi~o angular, mas a velocidade e
sentido de rotao do servomotor. Existe possibilidade de modificar, sem grande dificuldade,
um servomotor de posio para rotao contnua. Esta modificao permanente, no
podendo ser reversvel. No entanto, o objectivo deste subcaptulo no se centra nisso, mas
sim em como fazer a sua interaco com a plataforma de desenvolvimento Arduino.
4.3.1.2. detach()
Descrio: Permite eliminar a liga~o entre uma vari|vel do Servo a um dos pinos
possveis de utilizar pela biblioteca <Servo.h> (Pinos 9 e 10). Se nenhum dos pinos
possveis estiver atribudo a uma vari|vel do tipo Servo, os pinos 9 e 10 podem ser
utilizados normalmente.
Sintaxe:
Servo.detach();
Exemplo:
(1) #include<Servo.h> // Declarao da biblioteca <Servo.h>
(2) Servo Exemplo; // Criao de uma varivel do tipo Servo, com o nome de Exemplo
(3) void setup(){
(4) Exemplo.attach(10); // Atribuio da varivel do tipo Servo Exemplo, ao pino digital
10
(5) (..)
(6) void loop(){
(7) Exemplo.detach(); // Elimina a ligao entre a varivel do tipo Servo Exemploe pino
digital 10
(8) analogWrite(10, 255); // Como nenhuma varivel do tipo Servo se encontra atribuda,
podem-se usar as funcionalidades PWM dos pinos 9 e 10
(9) }
4.3.1.3. write()
Descrio: Permite movimentar o eixo de um servomotor de posio para o ngulo
pretendido. No caso de um servomotor de rotao contnua o valor 0 corresponder
velocidade de rotao mxima num sentido, o valor 180 a velocidade de rotao
mxima noutro sentido e o valor 90 ser o ponto em que o servomotor se encontrar
parado.
Sintaxe:
Servo.write(ngulo);
(3) Servo Exemplo_2; // Criao de uma varivel do tipo Servo, com o nome de
Exemplo_2
(4) void setup(){
(5) Exemplo.attach(10); // Atribuio da varivel do tipo Servo Exemplo, ao pino digital
10
(6) Exemplo_2.attach(9); // Atribuio da varivel do tipo Servo Exemplo_2, ao pino
digital 9
(7) (..)
(8) void loop(){
(9) Exemplo.write(0); // Faz com que um servomotor p.ex. de posio se movimente para a
posio correspondente ao ngulo 0
(1) Exemplo_2.write(90); // Faz com que um servomotor p.ex. de rotao contnua pare a
sua rotao
(11) }
4.3.1.4. read()
Descrio: Instruo que retorna o valor do ltimo ngulo utilizado, recorrendo
instru~o Servo.write(ngulo).
Sintaxe:
ngulo (int) = Servo.read();
4.3.1.5. attached()
Descrio: Instru~o que permite verificar se uma vari|vel do tipo Servo se encontra
atribuda a um pino especfico.
Sintaxe:
Estado (int) = Servo.attached();
Servo nome_a_atribuir;
Estado 0,1 , ou seja, s pode tomar o valor true (valor 1) ou false (valor
0).
Exemplo:
(1) #include<Servo.h> // Declarao da biblioteca <Servo.h>
(2) int atribuido=0; // Declarao de uma varivel do tipo integer de nome atribuido,
atribuindo-lhe o valor de 0
(3) Servo Exemplo; // Criao de uma varivel do tipo Servo, com o nome de Exemplo
(4) void setup(){
(5) Exemplo.attach(10); // Atribuio da varivel do tipo Servo Exemplo, ao pino digital
10
(6) (..)
(7) void loop(){
(8) atribuido = Exemplo.attached(); // Atribui o valor 1 varivel atribudo caso a varivel
do tipo Servo Exemplo se encontra associada a algum pino, caso contrrio retorna o
valor 0
(9) if (atribuido ==1){ //Se a varivel estiver do tipo Servo Exemplo estiver atribuda a
condio verificada
(10) Exemplo.write(180); // Faz com que um servomotor p.ex. de posio se movimente
para a posio correspondente ao valor 180
(11) }
(12) (..)
(13) }
O uso desta biblioteca simplifica a operao com servomotores, o que no implica que a
movimentao dos servomotores no seja feita com recurso directamente instruo
analogWrite(), ou seja, gerar os sinais PWM directamente. Tal , obviamente, possvel mas
mais trabalhoso, existindo esta biblioteca para simplificar esse trabalho de implementao.
Com este subcaptulo espera-se dar noes bsicas de funcionamento e uso de
servomotores, estando a partir daqui apenas dependente da criatividade de cada um na
implementao e aprofundamento do conhecimento sobre esta temtica.
Exemplo:
(1) #include<SoftwareSerial.h> // Declarao da biblioteca <SoftwareSerial.h>
(2) SoftwareSerial Exemplo = SoftwareSerial(4,5); // Declarao de uma varivel do tipo
SoftwareSerial de nome Exemplo, atribuindo-lhe o pino de Rx 4 e o pino de Tx 5
(3) void setup(){
(4) pinMode(4, INPUT); // Define o pino 4 como INPUT
(5) pinMode(5, OUTPUT); // Define o pino 5 como OUTPUT
4.4.1.3. read()
Descrio: Instruo que possibilita a leitura de um caracter proveniente do pino
definido como Rx. A instru~o SoftwareSerial.read() espera que chegue um caracter
e retorna o seu valor, sendo preciso ter em ateno que os dados que cheguam sem
haver uma leituraa aguardar ser~o perdidos (n~o existncia de buffer de recepo).
Sintaxe:
Valor Leitura (int/char) = SoftwareSerial.read();
SoftwareSerial Vari|vel do tipo SoftwareSerial, sendo definida da seguinte
forma:
SoftwareSerial Nome_varivel = SoftwareSerial(Pino de Rx, Pino de Tx);
Exemplo:
(1) #include<SoftwareSerial.h> // Declarao da biblioteca <SoftwareSerial.h>
(2) SoftwareSerial Exemplo = SoftwareSerial(4,5); // Declarao de uma varivel do tipo
SoftwareSerial de nome Exemplo, atribuindo-lhe o pino de Rx 4 e o pino de Tx 5
(3) char recebido; //Declarao de uma varivel do tipo char de nome recebido
(4) void setup(){
(5) pinMode(4, INPUT); // Define o pino 4 como INPUT
(6) pinMode(5, IOUTPUT); // Define o pino 5 como OUTPUT
(7) Exemplo.begin(9600); // Define a velocidade de comunicao com uma Baud rate de
9600
(8) void loop(){
(9) recebido = Exemplo.read(); //Possibilita guardar um valor recebido no pino de Rx, na
varivel do tipo char recebido
(10) }
SoftwareSerial.println(dado a enviar);
SoftwareSerial Vari|vel do tipo SoftwareSerial, sendo definida da seguinte
forma:
SoftwareSerial Nome_varivel = SoftwareSerial(Pino de Rx, Pino de Tx);
Exemplo:
(1) #include<SoftwareSerial.h> // Declarao da biblioteca <SoftwareSerial.h>
(2) SoftwareSerial Exemplo = SoftwareSerial(4,5); // Declarao de uma varivel do tipo
SoftwareSerial de nome Exemplo, atribuindo-lhe o pino de Rx 4 e o pino de Tx 5
(3) char recebido; //Declarao de uma varivel do tipo char de nome recebido
(4) void setup(){
(5) pinMode(4, INPUT); // Define o pino 4 como INPUT
(6) pinMode(5, IOUTPUT); // Define o pino 5 como OUTPUT
(7) Exemplo.begin(9600); // Define a velocidade de comunicao com uma Baud rate de
9600
(8) void loop(){
(9) recebido = Exemplo.read(); //Possibilita guardar um valor recebido no pino de Rx, na
varivel do tipo char recebido
(10) Exemplo.print(recebido); // Envia a varivel do tipo char de nome recebido, atravs
do pino definido com Tx (pino 5)
(11) }
() 1 () 2 () 3 ()
C/D Quantizer Encoder
Mas no entanto existe uma forma de configurar este factor de divis~o, fazendo variar
o contedo do bit ADPS0, ADPS1 e ADPS2 (Como se pode constatar pela anlise da figura
27).
Estes bits so parte integrante do registo ADCSRA, que constitudo da seguinte
forma:
Bit 7 6 5 4 3 2 1 0
(0x7A) ADEN ADSC ADATE ADIF ADIE ADPS2 ADPS1 ADPS0
Read/Write R/W R/W R/W R/W R/W R/W R/W R/W
Valor
0 0 0 0 0 0 0 0
Inicial
Pela anlise da tabela anterior, podemos afirmar ento que a maior frequncia de
amostragem que poderemos obter se situa nos 8 MHz. O que leva a que a que para haver uma
reconstruo sem perda de informao de um possvel sinal amostrado, o mesmo dever ter
uma frequncia mxima de 4 MHz. No entanto os valores apresentados na tabela 8 so
5. Concluso
Espera-se com este tutorial abrir as portas para um entendimento mais aprofundado
desta plataforma de desenvolvimento. No correspondendo este documento a tudo o que
existe para aprender e desenvolver sobre este tema. Muitos assuntos ficaram por abordar e
caber ao leitor caso tenha manifesto interesse (confunde-se muitas vezes com necessidade),
pesquisar e desenvolver uma temtica especfica.
A placa de desenvolvimento Arduino encontra-se em franca expanso, estando a sua
utilizao generalizada quer na rea da electrnica, artes e muitas mais. O que leva a que esta
plataforma tenha muitos seguidores e estando a crescer e a desenvolver-se a cada minuto que
passa. O que agora uma novidade de implementao, muito provavelmente quando estiver
a ler este tutorial ser uma coisa comum. Pois o Arduino est a conquistar o seu espao, e j
uma referncia.
Quem diria que um projecto acadmico chegaria to longe, provavelmente ningum
diria. O que faz com que as pessoas que acreditaram, estejam desde j de parabns pelo
magnfico trabalho. Deste exemplo real s podemos retirar que a persistncia e dedicao so
o que nos leva mais longe, pois os criadores desta plataforma de desenvolvimento no so os
melhores. Mas sim os que acreditaram e trabalharam para isso, o que se revela sempre muito
importante.
O que preciso ter uma atitude de contnua procura pelo conhecimento.
6. Bibliografia
Arduiniana. (2009). "Arduino software jewellry and wisdom." Retrieved 4 August 2009,
2009, from http://arduiniana.org/.
Arduino. (2006, 14 July 2009). Retrieved 21 July 2009, 2009, from
http://www.arduino.cc.
Arroz, G., J. Monteiro, et al. (2007). Arquitectura de Computadores dos Sistemas
Digitais aos Microprocessadores. Lisboa, IST Press.
AVR. (2009). "pgmspace reference." Retrieved 31 July 2009, 2009, from
http://www.nongnu.org/avr-libc/user-manual/group__avr__pgmspace.html.
Hayes, M. H. (1999). Schaums Outline of Theory and Problems of Digital Signal
Processing. Washington DC, USA, McGraw-Hill.
Igoe, T. (2007). Making Things Talk. Sebastopol, USA, OREILLY.
Santos, A. (2007). "Servomotores." Retrieved 31 July 2009, 2009, from
http://www.esen.pt/on/file.php/45/Cerqueira/Servo_Motor.pdf.
Santos, N. P. (2008) "Introduo ao Arduino." Revista PROGRAMAR, 39-44.
Santos, N. P. (2009) "Arduino e a Aquisio de dados." Revista PROGRAMAR, 24-26.
Shiffman, D. (2008). Learning Processing - A beginners Guide to Programming
Images, Animation, and Interaction. Burlington, USA, Morgan Kaufmann.
Sousa, D. J. d. S. and N. C. Lavinia (2006). Conectando o PIC 16F877A Recursos
Avanados. So Paulo, Brazil.
Tecnology, M. (1992). Advanced RISC Computing Specification. California, USA, MIPS
Technology.
Vasegui, S. V. (2006). Advanced Signal Processing and Noise Reduction. Wiltshire,
England, Wiley.