Iniciação Ao Arduino

Iniciação ao
Arduino
Lucínio Preza de Araújo

Blocos do Arduino
Entradas e saídas digitais
Conversor
Serial ↔ USB
Jack
USB
Cristal
CPU
Fonte de Atmel
alimentação
Microcontrolador
Jack
Alimentação
Terminais de alimentação Entradas analógicas

5V – 3,3V e Terra (0 V) ou saídas digitais
Resumo da placa Arduino uno
https://lucinio.wixsite.com/lucinioprezaaraujo Página 2
Arquitetura do Arduino
O microcontrolador
Um microcontrolador, ao contrário de um microprocessador, é desenhado e construído de forma

a integrar diversos componentes (CPU, RAM, ROM, Porta série, Porta paralela, etc.) num único
circuito integrado.
Microcontrolador: ATmega328.
Arduino uno - Caraterísticas
• Microcontrolador: ATmega328
• Tensão de operação: 5V
• Tensão recomendada (entrada): 7-12V
• Limite da tensão de entrada: 6-20V
• Pinos digitais: 14 (seis pinos com saída PWM)
• Entrada analógica: 6 pinos
• Corrente contínua por pino de entrada e saída: 40 mA
• Corrente para o pino de 3.3 V: 50 mA
• Quantidade de memória FLASH: 32 KB (ATmega328) onde 0.5 KB usado para o
bootloader
• Quantidade de memória SRAM: 2 KB (ATmega328)
• Quantidade de memória EEPROM: 1 KB (ATmega328)
• Velocidade de clock (cristal): 16 MHz
Arduino uno – Alimentação
Internamente, o circuito do Arduino é

alimentado com uma tensão de 5V.
O Arduino UNO pode ser alimentado

pela porta USB ou por uma entrada
do tipo “Power Jack” (com o positivo
ao centro) através de uma fonte
externa DC.
A recomendação é que a fonte

externa seja de 7 V a 12 V e pode ser ligada diretamente no conector de fonte ou nos
pinos Vin e Gnd.
A seguir são exibidos os conectores

de alimentação para conexão de
shields e módulos na placa Arduino
UNO:
3,3 V. - Fornece tensão de 3,3V. para

alimentação de shield e módulos
externos. Corrente máxima de 50 mA.
5 V - Fornece tensão de 5 V para
alimentação de shields e circuitos
externos.
GND - pinos de referência, terra.
VIN - pino para alimentar a placa
através de shield ou bateria externa. Quando a placa é alimentada através do conector
Jack, a tensão da fonte estará nesse pino.
Software
O 1º passo consiste em efectuar o download

do respectivo software de desenvolvimento, o
Arduino IDE 1.0.5, através do site oficial
Arduino
O 2º passo consiste em descompactar o
ficheiro “.ZIP” para uma pasta à sua escolha.
O 3º passo consiste em ligar a placa Arduino
ao computador através do cabo USB e instalar
os drivers FTDI, para permitir uma conversão
de USB para série.
O 4º passo consiste em configurar a porta
série a ser utilizada e qual o tipo de modelo
Arduino, que nos encontramos a utilizar. Para
tal, necessitamos de abrir o Software de
desenvolvimento e escolher na barra de
separadores a opção “Tools”.
O 5º passo para a utilização do Software
consiste em elaborar o seu Sketch (programa),
compilar e, caso não tenha erros, fazer o uploading para a placa Arduino.
Arduino IDE
O monitor serial é utilizado para

comunicação entre o Arduino e
o computador (PC).
As principais funcionalidades
do IDE do Arduino são:
- Escrever o código do
programa
- Salvar o código do programa
- Compilar um programa
- Transportar o código
compilado para a placa do
Arduino
Ciclo de desenvolvimento
Funções base
void setup() - Esta função apenas é executada uma vez e é normalmente utilizada
para executar a inicialização de variáveis, a inicialização da utilização bibliotecas, a
definição dos pinos (como input ou output), o início do uso de comunicação série, entre
outros. Esta função apenas volta a ser executada novamente ao ser efectuado o reset
ou quando se desligar e volta a ligar a placa de desenvolvimento Arduino.
void loop() - Esta função faz um “loop” sucessivo (como o próprio nome indica), ou
seja, todos os comandos existentes no interior desta função são sucessivamente
repetidos, o que pode permitir a leitura sucessiva de portas, a leitura sucessiva de
parâmetros provenientes de sensores externos e actuar de acordo com as condições
estabelecidas.
Programar no Arduino
Comentários
Muitas vezes é importante comentar alguma parte do código do programa.

Existem duas maneiras de adicionar comentários a um programa em Arduino.
A primeira é usando //, como no exemplo abaixo:

// Este é um comentário de linha
A segunda é usando /* */, como no exemplo abaixo:

/* Este é um comentário de bloco. Permite acrescentar comentários com mais de uma
linha */
Nota: Quando o programa é compilado os comentários são automaticamente suprimidos do arquivo

executável, aquele que será gravado na placa do Arduino.
Constantes
No Arduino existem algumas constantes previamente definidas e são consideradas

palavras reservadas.
As constantes definidas são:

true – indica valor lógico verdadeiro
false – indica valor lógico falso
HIGH – indica que uma porta está ativada, ou seja, está em 5V.
LOW – indica que uma porta está desativada, ou seja, está em 0V.
INPUT – indica que uma porta será de entrada de dados.
OUTPUT – indica que uma porta será de saída de dados.
Entradas analógicas e digitais
Portas digitais e analógicas

O Arduino possui tanto portas
digitais como portas analógicas.
As portas servem para
comunicação entre o Arduino e
dispositivos externos, por
exemplo: ler um botão, acender
um led ou uma lâmpada.
Conforme já mencionado, o
Arduino UNO, possui 14 portas
digitais e 6 portas analógicas
(que também podem ser
utilizadas como portas digitais).
Os conversores analógicos-
digitais (ADC) do Arduino são
de 10 bits.
Os valores lidos numa porta
analógica variam de 0 a 1023
(10 bits), onde 0 representa 0V e 1023 representa 5V.
Portas digitais
As portas digitais trabalham com valores bem definidos, ou seja, no caso do Arduino
esses valores são 0V e 5V.
0V indica a ausência de um sinal e 5V indica a presença de um sinal.
Para escrever numa porta digital basta utilizar a função digitalWrite(pin, estado).
Para ler um valor numa porta digital basta utilizar a função digitalRead(pin).
Saídas PWM
O que é PWM?
PWM, do inglês Pulse

Width Modulation, é uma
técnica utilizada por
sistemas digitais para
variação do valor médio
de uma forma de onda
periódica. A técnica
consiste em manter a
frequência de uma onda
quadrada fixa e variar o
tempo que o sinal fica em
nível lógico alto. Esse
tempo é chamado de duty
cycle, ou seja, o ciclo
ativo da forma de onda.
No gráfico ao lado são
exibidas algumas
modulações PWM.
Entradas analógica
Portas Analógicas
As portas analógicas são utilizadas para entrada de dados.

O Arduino UNO possui 6 (seis) portas analógicas.
As portas analógicas no Arduino UNO são identificadas como
A0, A1, A2, A3, A4 e A5. Estas portas também podem ser
identificadas por 14 (A0), 15 (A1), 16 (A2), 17 (A3), 18 (A4) e
19 (A5).
Por padrão todas as portas analógicas são definidas como

entrada de dados, desta forma não é necessário fazer esta
definição na função setup().
Os valores lidos numa porta analógica variam de 0V a 5V.

Para ler um valor numa porta analógica basta utilizar a função
analogRead(pin).
Para definir uma porta como entrada ou saída é necessário explicitar essa situação
no programa.
A função pinMode(pin, estado) é utilizada para definir se a porta será de entrada ou
saída de dados.
Exemplo:
Define que a porta 13 será de saída

pinMode(13, OUTPUT)
Define que a porta 7 será de entrada

pinMode(7, INPUT)
Programa explicado
/*
-----------------------------------
1º Exercício
-----------------------------------
Ligar e desligar um LED por um segundo
*/
//------------------------------------
//Função principal
//------------------------------------
void setup() // Executa-se quando o arduino é ligado
{
pinMode(13,OUTPUT); // Inicializa o pin 13 como uma saída
}
//------------------------------------
//Função repetitiva
//------------------------------------
void loop() // Esta função executa-se o instante todo
// quando está ligado o Arduino
{
digitalWrite(13,HIGH); // Liga o LED
delay(1000); // Temporiza um segundo (1s = 1000ms)
digitalWrite(13,LOW); // Desliga o LED
}
Numa linguagem de programação existem vários operadores que permitem operações

do tipo: Aritmética, Relacional, Lógica e Composta.
Shields
É possível agregar novas funcionalidades a

uma placa do Arduino.
As extensões das placas do Arduino são
chamadas de shields.
Existem shields para as mais diversas
funcionalidades, por exemplo:
Comunicação ethernet
Comunicação wifi
Comunicação bluethooth
Ponte H
Banco de relés
Adicionar uma biblioteca
Possivelmente algum dia vai precisar de adicionar uma biblioteca para trabalhar com
algum sensor ou outro componente no Arduino. Existem diversas bibliotecas
disponíveis na internet, que pode baixar e utilizar. Entretanto tem que adicioná-las ao
seu IDE para que o mesmo reconheça os comandos que está a utilizar.
Para mostrar como proceder, vamos adicionar a biblioteca MsTimer2.h como exemplo.
Primeiro vamos baixá-la na página do Arduino
(http://arduino.cc/playground/Main/MsTimer2). Feito isso, descompacte o arquivo.zip
que foi baixado. Agora vá até à pasta onde “instalou” o seu IDE para o Arduino e
procure pela pasta libraries. Dentro deste diretório copie a pasta que foi extraída
anteriormente.
Por fim, vamos verificar se a biblioteca foi mesmo detectada pelo IDE. Vá a Files >
Examples e verifique se a biblioteca que acabamos de adicionar está ali. Se sim, a
instalação ocorreu bem e já pode começar a utilizar a sua nova biblioteca. Agora é só
“chamá-la” no seu código, que neste caso ficaria: #include <MsTimer2.h>. Vale a pena
destacar que na própria página onde baixou a biblioteca, possui as instruções de como
utilizar a mesma.
Exercícios propostos
1. Faça um circuito onde três LEDs acendam em sequência, com um atraso de um

segundo entre eles, e depois apaguem igualmente em sequência.
2.Usando um LED vermelho, um amarelo e um verde, crie um semáforo de transito –

ou seja, o LED verde deve ficar ligado por um determinado intervalo de tempo, seguido
pelo amarelo, depois o vermelho, voltando para o verde.
3.Crie um LED inteligente: ou seja, utilizando um sensor de luminosidade, faça-o ligar

se o ambiente estiver escuro demais.
4.Projete o protótipo de uma fechadura com senha - ou seja, a porta só abre se a

senha digitada for correta. Para facilitar, utilize um LED vermelho para representar a
porta fechada e um LED verde para indicar que a senha digitada foi aceite.
5.Melhore seu protótipo adicionando um atuador sonoro, que avisa caso a senha esteja
errada, caso ela esteja certa, e denuncie, caso alguém erre a senha mais de três vezes
Utilize sons diferentes para cada caso.
Fontes de informação
Site oficial Arduino

http://www.arduino.cc
Para comandos, consultar o guia de referências em

http://arduino.cc/en/Reference/HomePage
Biblioteca MsTimer2
http://arduino.cc/playground/Main/MsTimer2
Simulador de Arduino: Virtual Breadboard

http://www.virtualbreadboard.com/Main.aspx?TAB=Downloads
Exercícios no Arduino
/*
Liga e desliga um LED por um segundo
*/
//------------------------------------
//------------------------------------
void setup() // Executa-se quando o arduino é ligado
{
pinMode(13,OUTPUT); // Inicializa o pin 13 como uma saída
}
//------------------------------------
//------------------------------------
void loop() // Esta função se executa o instante todo
// quando este ligado o Arduino
{
digitalWrite(13,HIGH); // Liga o LED
}
pinMode() digitalWrite() delay (milisegundos)

Descrição: Ao recorrer a esta instrução, Descrição: Possibilita, nos pinos Descrição: Possibilita
é possível configurar o modo de configurados como output através da efectuar uma pausa ao
comportamento de um determinado pino. instrução “pinMode”, estabelecer a programa em execução, por
Possibilitando assim defini-lo como input saída dos respectivos pinos com o uma quantidade de
ou output, esta definição normalmente é valor lógico 1 (HIGH – 5 V) ou com o milisegundos especificada.
efectuada recorrendo à função “void valor lógico 0 (LOW – 0V) Útil para manter um estado
setup()”. Sintaxe: durante uma certa
Sintaxe: digitalWrite(Número do pino, Modo); quantidade de tempo.
pinMode(Número do pino, Modo); O “Modo” acima descrito, pode ser Sintaxe:
O “Modo” acima descrito pode ser definido como: delay(tempo que deseja
definido da seguinte forma: “HIGH” efectuar a pausa – ms);
“INPUT” “LOW”
“OUTPUT”
Ligar via USB ao

computador através USB
do cabo USB A/B)
/*
-----------------------------------
Liga um LED com um botão
-----------------------------------
*/
//------------------------------------
//Declara os portos de entradas e saídas
Variável do tipo int
//------------------------------------ Descrição: Este tipo de variável
int botao=2; //Pino onde se encontra o botão, entrada (integer) permite guardar um valor
int led=13; //Pino onde se encontra o LED, saída inteiro.
//------------------------------------ Sintaxe:
int variável = valor
//------------------------------------
void setup()
{
pinMode(botao, INPUT); //Configura a entrada digitalRead()
pinMode(led,OUTPUT); //Configurar a saída Descrição: Possibilita a leitura de
} uma entrada digital específica,
retornando um valor no formato
//------------------------------------ integer (int). Se obtivermos um
//Função cíclica valor de retorno de “1”, estamos
//------------------------------------ perante uma leitura do tipo
void loop() “HIGH” (valor lógico 1). Se tal não
se verificar, e tivermos um valor
{
de retorno igual a “0”, estamos
//Condicional para saber o estado do botão perante uma leitura do tipo “LOW”
if (digitalRead(botao)==HIGH) (valor lógico 0).
{ Ciclo If…….else
//Botão pressionado É utilizado para descrever uma
condição, ou seja, quando uma
digitalWrite(led,HIGH); //Liga o LED variável for: igual, maior, menor ou
} diferente (de acordo com a
else declaração efectuada) a um
{ determinado valor é executada uma
//Botão NAO pressionado determinada condição. Podem-se
usar vários ciclos if….else
digitalWrite(led,LOW); //desliga o LED encadeados, de forma a verificar
} diversas condições.
5V DC
/*
--------------------------------------
Leitura serial de uma entrada digital
--------------------------------------
Lê uma entrada digital e apresenta no ecrã do computador (console serial) o estado do botão
quando é pressionado.
*/
//------------------------------------
//Declara os pinos de entradas e saídas
//------------------------------------
int botao=2;
//------------------------------------
//------------------------------------
void setup()
{
//Configuração
Serial.begin(int baud rate)
pinMode(botao,INPUT); //Configura o botão como entrada
Descrição: Instrução
Serial.begin(9600); //Inicia a comunicação serial necessária para iniciar a
} comunicação série,
//------------------------------------ permitindo definir qual a
//Função cíclica “baud rate” da comunicação.
Os valores de velocidade de
//------------------------------------ comunicação mais comuns
void loop() para comunicação com um
{ computador são: 300, 1200,
//salva em uma variável inteira o valor do botão 0 ou 1 2400, 4800, 9600, 14400,
int estado = digitalRead(botao); 19200, 28800, 38400,
57600 e 115200 (No entanto
//Condicional para saber o estado do botão podem definir-se outros
if (estado==1) valores).
{ Sintaxe:
// pressionado Serial.begin( int baud rate);
Serial.print("Ligado"); //Imprime na consola serial
}
else Serial.print()
{ Descrição: Instrução que
// Não está pressionado permite o envio de dados
pela porta série.
Serial.print("desligado"); Sintaxe:
} Serial.print(dado a enviar);
delay(100);//Retardo para visualizar os dados no ecrã.
}
Cabo
USB B – RS232
USB
5V DC
/*
--------------------------------------
Leitura serial de uma entrada analógica
--------------------------------------
Lê uma entrada analógica e apresenta no ecrã do computador
(console serial) o valor do potenciómetro
*/
//------------------------------------
//------------------------------------
void setup()
{
Serial.begin(9600); //Inicia comunicação serial
}
//------------------------------------
//------------------------------------
void loop()
{
//Guarda numa variável inteira o valor do potenciómetro
0 a 1024
int valor= analogRead(A0);
//Imprime na console serial o valor da variável
Serial.print(valor);
//Atraso para a visualização dos dados no ecrã
delay(100);
}
analogRead()
Descrição: Possibilita a leitura do valor analógico do pino especificado, com um conversor A/D possuindo uma
resolução de 10 bits. O que leva a que um valor compreendido entre 0 e 5 V, esteja compreendido entre os valores
inteiros (int) 0 e 1023.
Sintaxe:
Variável do tipo integer = analogRead(Número do pino)
Porta
Série
USB
5V
DC
/*
--------------------------------------
Escrita serial
--------------------------------------
Escrever no ecrã do computador (console serial) uma letra predefinida, a primeira vez
que seja escrita ligará um led, se é reescrita pela segunda vez o led é desligado
*/
//--------------------------------------------------
//Declara os portos de entrada e saídas e variáveis
//--------------------------------------------------
int led = 13; //Pino onde se encontra o LED, saída
char letra; //Variável onde se guarda a letra
boolean ligado=false; //Estado do LED a primeira vez, desligado
//------------------------------------
//------------------------------------
void setup()
{
pinMode(led, OUTPUT); //Configura o LED como uma saída
}
//------------------------------------
//Função cíclica
//------------------------------------
void loop()
{
//Guarda numa variável o valor da console serial
letra=Serial.read();
// Se é a letra 'L' e o LED está desligado
if ( (letra=='L') && (ligado==false) )
{
digitalWrite(led,HIGH); // liga o LED
ligado=true; // Atualiza o estado do LED
}
// Se é a letra 'L' e o LED está ligado
else if ( (letra=='L') && (ligado==true) )
{
digitalWrite(led,LOW); // desliga o LED
ligado=false; // Atualiza o estado do LED
}
}
/*
---------------------------------------------
Liga/desliga um LED de forma proporcional
---------------------------------------------
Programa que liga proporcionalmente um LED quando chega ao seu ponto máximo de
intensidade começa a desligar proporcionalmente.
*/
//--------------------------------------------------
//Declara os portos de entradas, saídas e variáveis
//--------------------------------------------------
int brilho = 0; //Variável de brilho inicia em 0
int variacao = 5; //Variável de incremento configurada de 5 em 5
int led = 9; //Pino onde se encontra o LED, saída
//------------------------------------
//------------------------------------
void setup ()
{
pinMode(led, OUTPUT); //Configura o LED como uma saida
}
//------------------------------------
//Função cíclica
//------------------------------------
void loop ()
{
// Escrita analógica (PWM) no LED escrevo o valor de brilho
analogWrite(led, brilho);
// Incremento a variável brilho de 5 em 5
brilho = brilho + variacao;
// Notação: PWM ----> 0 - 255
// Se o brilho é 0 o 255
if (brilho == 0 || brilho == 255)
variacao = -variacao; //a variação se volta negativa
delay (30); //Tempo de incremento no brilho
}
/*
---------------------------------------------
Controle ON/OFF com potenciómetro
---------------------------------------------
Programa que liga um LED quando o valor da entrada analógica comandada pelo
potenciómetro está em determinado valor, quando este valor varia o LED desliga-se,
correspondendo a um sistema com controlo ON/OFF
*/
//------------------------------------
//------------------------------------
void setup()
{
pinMode(13,OUTPUT); //Configura o pin 13 como uma saída
}
//------------------------------------
//Função cíclica
//------------------------------------
void loop()
{
//Salva em uma variável o valor da leitura analógica
int valor = analogRead(A0);
Serial.println(valor); //Imprime o valor pela console
//Se o valor é maior o igual a 500
if (valor >= 500)
{
digitalWrite(13,HIGH); //Liga o LED no pino 13
}
//Se o valor é menor a 500
else
{
digitalWrite(13,LOW); //Desliga o LED no pino 13
}
delay(100); //Retardo de 100ms para obter os dados da consola
}
/*
---------------------------------------------
Controle de intensidade de um LED
---------------------------------------------
Programa que liga um LED de maneira proporcional de acordo à quantidade de luz que
incida numa fotoresistência LDR.
*/
//------------------------------------
//------------------------------------
void setup()
{
Serial.begin(9600);
pinMode(9,OUTPUT); //Configura o pin 9 como una saida,PWM
}
//------------------------------------
//Função cíclica
//------------------------------------
void loop()
{
//salva em uma variável o valor da leitura analógica da LDR
int foto = analogRead(A0);
//Verifica o valor máximo e realiza uma conversão
int conversao = 780 - foto;
//Condicional para estabelecer um valor absoluto
if ( conversao < 0)
conversao = conversao * -1; //Multiplica por -1 por que é negativo
//Imprimir dados do valor da leitura analógica da LDR
Serial.print("LDR : ");
Serial.print(foto);
Serial.println("");
//Imprimir dados do valor da conversão
Serial.print("Conv : ");
Serial.print(conversao);
Serial.println("");
//Escrita analógica de PWM no LED de acordo à conversão
analogWrite(9, conversao);
delay(100); //Retardo para dados na console
}
/*
---------------------------------------------
Contador de pulsos
---------------------------------------------
Programa que apresenta no ecrã (console serial) o número de vezes que o botão tem
sido premido, realiza-se um processo que de acordo com o número de vezes que o
botão foi premido se liga um LED.
*/
//--------------------------------------------------
//Declara os portos de entradas, saídas e variáveis
//--------------------------------------------------
int conta = 0; //Variável para salvar o centeio dos pulsos
//------------------------------------
//------------------------------------
void setup() /
{
Serial.begin(9600);
pinMode(2,INPUT); //Configura o pino 2 como uma entrada, botão
pinMode(13,OUTPUT); //Configura o pino 13 como uma saída, LED
}
//------------------------------------
//Função cíclica
//------------------------------------
void loop()
{
// Se o botão esta oprimido
if ( digitalRead(2) == HIGH )
{
// Se o botao não esta oprimido, flanco de baixada
if ( digitalRead(2) == LOW )
{
conta++; //Acrescenta o contador
Serial.println(conta); //Imprime o valor pela console
delay (100); // Retardo
}
}
// Se o valor do contador é 5
if (conta==5)
{
digitalWrite(13,HIGH); //Liga o LED
}
// Se o valor do contador é 8
if (conta==8)
{
}
}
/*
---------------------------------------------
Interruptor magnético para gerar um alerta
---------------------------------------------
Programa que gera uma alarma visual com um LED a partir de um campo magnético
gerado por um reed switch.
*/
int contato = 2; //Pino assignado ao reed switch
int led= 13; //Pino assignado ao LED
//------------------------------------
//------------------------------------
void setup()
{
pinMode(contato,INPUT); //O reed switch como uma entrada
pinMode(led, OUTPUT); //o LED como uma saída
}
//------------------------------------
//Função cíclica
//------------------------------------
void loop()
{
// Se o íman se aproxima ao reed switch
if (digitalRead(contato)==LOW){
//Ciclo for que vai de 0 a 50, o contador esta
//na variable a, se repete se é menor de 50
for(int a=0; a<50; a++){
digitalWrite(led,HIGH); //Liga o LED
delay(50); //Tempo
digitalWrite(led,LOW); //Desliga o LED
delay(50); //Tempo
}
// Se o íman esta longe do reed switch
}else{
digitalWrite(led,LOW); //Mantém desligado o LED
}
}
/*
---------------------------------------------
Controle básico de um LED RGB – semáforo
---------------------------------------------
Programa que gera uma alarma visual com um LED a partir de um campo magnético
gerado por um reed switch.
*/
//--------------------------------------------------
//Declara portos de entradas, saídas e variáveis
//--------------------------------------------------
int ledDelay = 10000; // retardo para o cambio de luz
int vermelhoPino = 10;
int amareloPino = 9;
int verdePino = 8;
//------------------------------------
//------------------------------------
void setup() {
pinMode(vermelhoPino, OUTPUT);
pinMode(amarelhoPino, OUTPUT);
pinMode(verdePino, OUTPUT);
}
//------------------------------------
//Função cíclica
//------------------------------------
void loop() {
digitalWrite(vermelhoPino, HIGH); // liga a luz vermelha
delay(ledDelay); // aguarda 5 seg
digitalWrite(amareloPino, HIGH); // liga a luz amarela
delay(2000); // aguarda 2 seg
digitalWrite(verdePino, HIGH); // liga a luz verde
digitalWrite(vermelhoPino, LOW); // desliga a luz vermelha
digitalWrite(amareloPino, LOW); // desliga a luz amarela
delay(ledDelay); // aguarda o ledDelay
digitalWrite(amareloPino, HIGH); // liga a luz amarela
digitalWrite(verdePino, LOW); // desliga a luz verde
delay(2000); // aguarda 2 seg
digitalWrite(amareloPino, LOW); // desliga a luz amarela
}
/*
---------------------------------------------
Controle ON/OFF de um motor
---------------------------------------------
Programa que faz uso de um motor e um botão, Se é mantido pressionado, o motor
deve estar ligado (ON) se não deve estar desligado (OFF)
*/
//--------------------------------------------------
//Declara portos de entradas, saídas e variáveis
//--------------------------------------------------
int botao=7; //Declara Pino do botão
int motor=3; //Declara Pino do motor
//------------------------------------
//------------------------------------
void setup()
{
pinMode(botao,INPUT);
pinMode(motor,OUTPUT);
}
//------------------------------------
//Função cíclica
//------------------------------------
void loop()
{
// Se o botao se encontra premido
if(digitalRead(botao) == HIGH){
digitalWrite(motor,HIGH); //liga o motor
}else{ //se o botao não esta premido
digitalWrite(motor,LOW); //desliga o motor
}
}
/*
---------------------------------------------
Controle por PWM de um motor
---------------------------------------------
Programa que faz uso de um motor e a Console serial de Arduino, tem a possibilidade de
configurar o motor em 5 velocidades distintas, desde o teclado do PC pode-se enviar a
velocidade desejada. As 5 velocidades configuram-se com 5 PWM distintos.
*/
//--------------------------------------------------
//Declara portos de entrada, saídas e variáveis
//--------------------------------------------------
int motor=3; //Declara Pino do motor
//------------------------------------
//------------------------------------
void setup()
{
Serial.begin(9600);
}
//------------------------------------
//Função cíclica
//------------------------------------
void loop()
{
// Se tem algum valor na consola serial
if (Serial.available()){
//Variável onde se salva o caráter enviado desde o teclado
char a = Serial.read();
// Se o caráter ingressado esta entre 0 e 5
if (a>='0' && a<='5'){
//Variável para escalar o valor ingressado na faixa de PWM
int velocidade = map(a,'0','5',0,255);
//Escrita de PWM ao motor
analogWrite(motor,velocidade);
//Mensagem para o usuário
Serial.print("o motor esta girando à velocidade ");
Serial.println(a);
}else{ // Se o caráter ingressado não esta entre 0 e 5
//Mensagem para o usuário
Serial.print("Velocidade invalida");
Serial.println(a);
}
}
}
Fonte: http://arduino.labdegaragem.com/
Montagem prática com o
Arduino
Robô
detetor de obstáculos
Fonte: https://uriedubot.wordpress.com/
Introdução ao projeto
A ideia do projeto surgiu de estudos realizados por mim sobre programação, robótica e a placa
Arduino.
Este projeto engloba componentes de hardware (mecânica e eletrónica) e software

(programação).
O robô proposto é móvel, autónomo e trabalha em ambientes desconhecidos.
Um algoritmo faz a identificação dos obstáculos para verificar se o robô executa ou não
manobras evasivas, evitando a sua colisão
Arquitetura do robô
O projeto será composto por apenas cinco componentes de hardware: os dois motores
de 4,5 V DC / 250 mA, o sensor ultra-sónico SRF05 de 5 V / 4mA, o Arduino Uno e
uma Arduino shield MotoMama – L298 de 5 V para realizar a ligação/controlo dos
motores.
O Arduino serve como ponte entre o sensor ultra-sónico e os atuadores (motores), transmitindo-
lhes as instruções provenientes do firmware/software.
A comunicação entre a interface de controlo e o dispositivo dá-se através de uma ligação serial
padrão.
O diagrama de blocos do projeto pode ser visto na figura seguinte.
Os motores DC (4,5 V / 250 mA)
Diferente dos motores de passo e dos motores de corrente

alternada, o controle da velocidade de um motor DC é
relativamente simples. O objetivo é realizar o controlo
independente de dois motores DC, que estão fixados no
chassi do robô, para que o mesmo seja capaz de se deslocar
em qualquer direção.
O controlo dos motores é realizado através de PWM que
significa modulação por largura de pulso (Pulse Width
Modulation) e é basicamente uma técnica para obtermos
resultados analógicos com meios digitais.
O controle digital é usado para criar uma onda

quadrada, entre ligado e desligado. Assim a técnica
consiste em manipularmos a razão cíclica de um sinal,
o duty cycle afim de transportar informação ou
controlar a potência de outro circuito. Com isso,
teremos um sinal digital que oscila entre 0v e 5v com
determinada frequência (o Arduino trabalha com um
padrão próximo a 500 Hz). O duty cycle é a razão do
tempo em que o sinal permanece em 5v sobre o
tempo total de oscilação, como está ilustrado na
figura.
Portanto, o que controlamos através

do software é justamente o duty
cycle, ou seja, a percentagem de
tempo em que o sinal fica em 5v.
Dessa forma, podemos utilizar essa
técnica para limitar a potência de
um circuito, como por exemplo,
controlar um motor.
A função analogWrite (), apesar de

estarmos a utilizar uma porta digital,
é a responsável pelo PWM e recebe
como parâmetro o pino e um valor
entre 0 – 255, em que o 0
corresponde a 0% e 255
corresponde a 100% do duty cycle.
Sensor ultrasónico (SRF05 de 5 V / 4mA)
O uso de sensores para a detecção de obstáculos

possibilita o aumento da precisão do deslocamento do
robô num dado espaço, uma vez que permite que o
robô diminua a sua incerteza em relação à sua
localização dentro desse mesmo espaço. Ele determina
a distância de um objeto utilizando o sonar para se
desviar dos obstáculos.
O princípio do sonar baseia-se no envio de um sinal (neste caso, na faixa de ultra-som:
de 40 KHz) e a detecção do seu eco, que é um pulso em nível alto que corresponde ao
tempo de ida e volta do som, ou seja, é necessário dividir este tempo por 2.
Este sensor pode

ser ligado, de duas
maneiras
diferentes à placa
Arduino: ou
utilizando quatro
Pinos de
programação.
condutores (modo
Fonte 5 V DC Usados somente 1 compatível com
Echo (Saída) uma vez para o seu predecessor
programar o chip do
Trigger (Entrada)
PIC durante o fabrico.
o sensor SRF-04)
Não é ligado ou utilizando três
Não fazer ligações
0 V (terra) nestes terminais. condutores (modo
2). O modo 2
requer menos fios,
no entanto a
programação
complica-se já que
Modo 1 – ligações para dois pinos Trigger/Echo (compatível com o SRF-04)
o mesmo pino terá
de alternar entre
ser entrada e
saída, conforme as
circunstâncias
No modo 1 o pino “Echo” tem de ser ligado a um pino de entrada digital da placa
Arduino e o pino “Trigger” a um pino de saída digital da placa Arduino. Este pino
“Trigger” é responsável por geral um impulso com uma duração exata de 10 µs, o qual
marca o início do envio do sinal ultra-sónico, e o pino “Echo” conta o tempo decorrido
entre o envio e a receção do ultra-som.
Arduino Shield (MotoMama – L298 de 5 V)
Nunca se deve ligar um motor directamente ao Arduino

mesmo que seja de 4,5V, pois eles têm um consumo
elevado (250 mA) e podem queimar o Arduino, para isso
é que se usa a ponte H shield MotoMama – L298, que
além do controlo, fornece potência quando alimentada a
uma fonte/bateria.
A ponte H utilizada para inverter a rotação do motor é um circuito bem simples composto
por 4 interruptores, um motor e uma fonte de energia.
Observe a figura abaixo. Acionando o interruptor S1 e o S4, o sentido da corrente será

da esquerda para a direita, acionando o motor. Se desligarmos os interruptores S1 e
S4 e ligarmos os interruptores S2 e S3, o sentido da corrente passa a ser da direita
para a esquerda, invertendo o sentido de rotação do motor. Este é o conceito de ponte
H.
OUT1 / OUT2 é completamente

simétrica com o OUT3 / OUT4.
Estes terminais vão ligar aos dois
motores de corrente contínua.
A porta de entrada de A tem três

pinos, In1, In2 e EnA.
In1 e In2 são portas digitais que
são utilizadas para controlar a
direcção do motor, EnA tem
In4
In3 ligação com a porta de PWM de
EnB
EnA placa de controlo (Arduino Uno)
In2 para controlar a velocidade do
In1
motor.
A porta A é usada para controlar o
motor que é ligado a OUT1 e
OUT2.
A porta B é usada para controlar o
motor que é ligado a OUT3 e
MotoMama – L298 visto de cima OUT4.
As ligações
A complexidade de um robô passa pelas dificuldades dos projetos mecânicos e elétricos, mas o
principal desafio é, com certeza, dar ao dispositivo a “inteligência” necessária para que ele possa
desempenhar as suas tarefas.
O projeto usa a plataforma open-source Arduino.
Os pinos de saída digital
(output) 3, 4, 9. 5, 6 e 10
do Arduino são ligados
nos pinos de entrada
(input) da shield Arduino
para fazer o acionamento
dos motores.
Para ligar o Arduino com
o sensor ultrasónico são
ligados os pinos digitais
13 e 12 do Arduino com
os pinos “Trig” e “Eco”
do sensor ultra-sónico.
Detalhes sobre as ligações entre os equipamentos podem ser observados na seguinte tabela.
Fontes de Sensor Motor

Arduino Uno Shield Motor Motor direito
alimentação (MotoMama – L298) ultrasónico esquerdo
(SRF05)
9 V DC Jack power
5 V DC 5 V DC 5 V supply
Pino 12 Echo (output)
Entrada digital
Pino 13 Trigger (input)
Saída digital
GND GND 0 V (ground)
6 V DC Vin
Controla a
Pino 10 (PWM) EnA corrente para o
motor
Porta de
Pino 5 In1 entrada Roda para a
(porta digital) de A direita
Pino 6 In2 Roda para a

(porta digital) esquerda
Controla a
Pino 9 (PWM) EnB corrente para o
motor
Porta de
Pino 3 In3 entrada Roda para a
(porta digital) de B direita
Pino 4 In4 Roda para a

(porta digital) esquerda
OUT 1 / OUT 2 Alimentação
Porta A
OUT 3 / OUT 4 Alimentação
Porta B
9V Arduino Uno
DC
SRF-05
5 V DC
Echo
Trigger
10
5V
9
0V
GND
D
6
5
4
3
Motores DC
6V
DC
In4
In3
EnB
EnA
In2
In1
MotoMama – L298 visto de cima
O programa – Firmware
A linguagem utilizada é a WIRING uma linguagem de programação baseada em C/C++ para

escrever e ler nas entradas/saídas digitais e analógicas do Arduino.
O programa desenvolvido lê os valores do sensor ultrasónico e quando recebe a reflexão de volta
de algum obstáculo os motores DC são ativados.
Um conversor USB-TTL FTDI no Arduino encaminha o firmware através da comunicação serial

USB.
Códigos
Sketch base para o Robô.

Controlo dos dois motores com sensor para desviar o robô dos obstáculos e fazer as manobras
evasivas necessárias.
Sketch
// Autor: Carlos Solon G. Jr

// Data: 08/2011
// O robô possui dois motores DC independentes.
// cada motor tem dois fios
//MOTOR DIREITA – pinos para controlar o motor

#define DIR_VEL 10 // pino 10 Arduino – controla a corrente para o motor da
direita
#define DIR_PIN1 5 //pino 5 do Arduino
#define DIR_PIN2 6 //pino 6 do arduino
//MOTOR ESQUERDA – pinos para controlar o motor

#define ESQ_VEL 9 // pino 9 do Arduino – controla a corrente para o motor
da esquerda
#define ESQ_PIN1 3 //pino 3 do Arduino
#define ESQ_PIN2 4 //pino 4 do arduino
#define ECHO 12 // Pino 12 do Arduino – eco (rx) – onda refletida pelo

objeto é capturada pelo sonar
#define TRIG 13 // Pino 13 Arduino – Trig (tx) – transmitido como ultrassom
pelo ar – sonar.
#define NORMAL_VEL 255 // Valor constante para alimentar os motores. Valores

de 0 à 255.
#define PARA_VEL 0
// A função Setup apenas é executada uma vez é

// normalmente utilizada para executar a inicialização
// de variáveis ou pinos por exemplo.
void setup()
{
Serial.begin(9600); // Permite a inicialização da comunicação Série - USB.
setupMove(); // Chamada de função que seta os pinos dos motores com saída
(OUTPUT). E prepara os motores colocando os pinos em LOW – baixo.
setupUltrasonic(); //Seta os pinos do Sensor ultrasónico e prepara o pino
trigger em LOW – baixo
}
void loop()
{
unsigned int d; // declara um inteiro e faz com que só suporte números
positivos.
moveFrente(); // Função para mover motores para frente
d = leDistancia(); // a variável d recebe o retorno da função leDistancia
Serial.println(d, DEC); // Imprime no serial monitor a distância.
if (d <= 20) // verifica se a distância é menor que 20 cm
{
moveTras(); // função para mover para trás
delay(500); // metade de um segundo – em 1 segundo existem 1000
milissegundos.
moveEsquerda(); // função para mover para esquerda
delay(200); // 200 milissegundos
}
void moveFrente() // Implementação da função para acionar os motores para

frente.
{
analogWrite(ESQ_VEL, NORMAL_VEL); //Possibilita a utilização dos pinos PWM.
analogWrite(ESQ_VEL, 255); Valores de 0 à 255.
digitalWrite(ESQ_PIN1, LOW); // digitalWrite passa como parâmetro o pino e as
constantes HIGH/LOW
digitalWrite(ESQ_PIN2, HIGH);
analogWrite(DIR_VEL, NORMAL_VEL);
digitalWrite(DIR_PIN1, LOW);
digitalWrite(DIR_PIN2, HIGH);
}
void moveTras() // Implementação da função para acionar os motores para trás.

{
digitalWrite(ESQ_PIN1, HIGH); // digitalWrite passa como parâmetro o pino e
as constantes HIGH/LOW
digitalWrite(ESQ_PIN2, LOW);
}
void moveEsquerda() // Implementação da função para acionar os motores para

esquerda.
{
digitalWrite(ESQ_PIN1, HIGH); // digitalWrite passa como parâmetro o pino e
as constantes HIGH/LOW
}
void moveDireita() // Implementação da função para acionar os motores para

direita.
{
constantes HIGH/LOW
digitalWrite(ESQ_PIN2, HIGH);
}
void movePara() // Implementação da função para parar os motores.

{
analogWrite(ESQ_VEL, PARA_VEL); //Possibilita a utilização dos pinos PWM.
constantes HIGH/LOW
analogWrite(DIR_VEL, PARA_VEL);
}
void setupMove() // seta os pinos dos motores como saída

{
pinMode(ESQ_VEL, OUTPUT);
pinMode(ESQ_PIN1, OUTPUT);
pinMode(ESQ_PIN2, OUTPUT);
pinMode(DIR_VEL, OUTPUT);
pinMode(DIR_PIN1, OUTPUT);
pinMode(DIR_PIN2, OUTPUT);
analogWrite(ESQ_VEL, PARA_VEL); //Possibilita a utilização dos pinos PWM.

constantes HIGH/LOW
analogWrite(DIR_VEL, PARA_VEL);
}
unsigned int leDistancia() // Implementação da função do sonar. Retorna a

distância em cm.
{
int duracao; // Variável para receber o comprimento do pulso em microssegundos

e dividir por 58.
digitalWrite(TRIG, LOW);//Deixa trig em baixo
delayMicroseconds(2);// por 2 uS - microssegundos
digitalWrite(TRIG, HIGH); //Deixa trig em estado alto, Um sinal de um pulso
curto de 10uS é disparado
delayMicroseconds(10); //O sensor envia uma ‘explosão’ de 8 ciclos de ultra-
som em 40khz
digitalWrite(TRIG, LOW); // diminui a sua linha de eco para LOW - baixo.
duracao = pulseIn(ECHO, HIGH); // aumenta a sua linha de eco para alto.
// Lê um pulso (HIGH ou LOW) em um pino. Retorna o comprimento do pulso em
microssegundos.
//pulseIn retorna (tempo de alto nível * velocidade do som (340M/S)/2).
return duracao/58; //retorna a divisão por 58 da duração para converter em
centímetro.
void setupUltrasonic() // seta os pinos do sonar e prepara o trigger como LOW

{
pinMode(TRIG, OUTPUT); // seta pin 13 como saída - transmissor - trigger
pinMode(ECHO, INPUT); // seta pin 12 como entrada - receptor - echo
digitalWrite(TRIG, LOW);
}

Iniciação Ao Arduino

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Iniciação Ao Arduino

Enviado por

Direitos autorais:

Formatos disponíveis

Iniciação ao

Lucínio Preza de Araújo

Entradas e saídas digitais

Terminais de alimentação Entradas analógicas

Resumo da placa Arduino uno

Um microcontrolador, ao contrário de um microprocessador, é desenhado e construído de forma

Arduino uno – Alimentação

Internamente, o circuito do Arduino é

O Arduino UNO pode ser alimentado

A recomendação é que a fonte

A seguir são exibidos os conectores

3,3 V. - Fornece tensão de 3,3V. para

O 1º passo consiste em efectuar o download

O monitor serial é utilizado para

- Salvar o código do programa

Muitas vezes é importante comentar alguma parte do código do programa.

A primeira é usando //, como no exemplo abaixo:

A segunda é usando /* */, como no exemplo abaixo:

Nota: Quando o programa é compilado os comentários são automaticamente suprimidos do arquivo

No Arduino existem algumas constantes previamente definidas e são consideradas

As constantes definidas são:

Entradas analógicas e digitais

Portas digitais e analógicas

PWM, do inglês Pulse

As portas analógicas são utilizadas para entrada de dados.

Por padrão todas as portas analógicas são definidas como

Os valores lidos numa porta analógica variam de 0V a 5V.

Define que a porta 13 será de saída

Define que a porta 7 será de entrada

Numa linguagem de programação existem vários operadores que permitem operações

É possível agregar novas funcionalidades a

Adicionar uma biblioteca

1. Faça um circuito onde três LEDs acendam em sequência, com um atraso de um

2.Usando um LED vermelho, um amarelo e um verde, crie um semáforo de transito –

3.Crie um LED inteligente: ou seja, utilizando um sensor de luminosidade, faça-o ligar

4.Projete o protótipo de uma fechadura com senha - ou seja, a porta só abre se a

Site oficial Arduino

Para comandos, consultar o guia de referências em

Simulador de Arduino: Virtual Breadboard

pinMode() digitalWrite() delay (milisegundos)

Ligar via USB ao

Este projeto engloba componentes de hardware (mecânica e eletrónica) e software

O diagrama de blocos do projeto pode ser visto na figura seguinte.

Diferente dos motores de passo e dos motores de corrente

O controle digital é usado para criar uma onda

Portanto, o que controlamos através

A função analogWrite (), apesar de

O uso de sensores para a detecção de obstáculos

Este sensor pode

Arduino Shield (MotoMama – L298 de 5 V)

Nunca se deve ligar um motor directamente ao Arduino

Observe a figura abaixo. Acionando o interruptor S1 e o S4, o sentido da corrente será

OUT1 / OUT2 é completamente

A porta de entrada de A tem três

Fontes de Sensor Motor

GND GND 0 V (ground)

Pino 6 In2 Roda para a

Pino 4 In4 Roda para a

MotoMama – L298 visto de cima

A linguagem utilizada é a WIRING uma linguagem de programação baseada em C/C++ para

Um conversor USB-TTL FTDI no Arduino encaminha o firmware através da comunicação serial

Sketch base para o Robô.

// Autor: Carlos Solon G. Jr