Prototipagem com Arduino

"faça você mesmo" (DIY - do-it-yourself)

Professor: Felipe Sanches
LINKS ÚTEIS
• [1] http://br-arduino.org/
• [2] http://labdegaragem.com/
• [3] http://br-linux.org/
• [4] https://www.robocore.net/
• [5] http://br-arduino.org/2014/12/usando-o-led-interno-do-arduino-para-exibir-
numeros.html
• [6] http://br-arduino.org/2014/12/criando-uma-biblioteca-para-o-arduino-para-
facilitar-o-reuso-de-suas-funcoes.html
• [7] Arduino.cc
• [8] https://www.embarcados.com.br/
• [9] http://www.comofazerascoisas.com.br/
• [10] http://www.filipeflop.com/
Softwares
 Introdução
A Wikipédia afirma que “Um Arduino é um microcontrolador de placa única e um
conjunto de software para programá-lo. O hardware consiste em um projeto simples de
hardware livre para o controlador, com um processador Atmel AVR e suporte embutido
de entrada/saída. O software consiste de uma linguagem de programação padrão e do
bootloader que roda na placa.”
 Bootloader
Sistema básico inicializado sempre que o aparelho é ligado. Também chamado de carregador de
boot, eles são encontrados em qualquer computador com um sistema operacional
 Código fonte aberto
Software de código aberto (do inglês open source software ou OSS) é o software de computador
com o seu código fonte disponibilizado e licenciado com uma licença de código aberto no qual o
direito autoral fornece o direito de estudar, modificar e distribuir o software de graça para
qualquer um e para qualquer finalidade ...
 SHIELD
Um dos maiores atrativos da plataforma Arduino é o fato de que é possível desenvolver projetos
de dispositivos conectados. Os shields de conexão permitem uma série de opções para que seu
Arduino fale com o mundo através de uma rede.

Ethernet Bluetooth
Qual comprar?
Comparação
Arquitetura/pinos
SAÍDA PWM

A placa Arduino Uno

possui pinos específicos
para saídas PWM e são
indicados pelo caracter ‘~’
na frente de seu número
 Pino de Alimentação
A placa pode ser alimentada pela conexão USB ou por uma fonte de alimentação externa, conforme
exibido na figura abaixo:
IOREF - Fornece uma tensão de referência para que shields
possam selecionar o tipo de interface apropriada, dessa forma
shields que funcionam com a placas Arduino que são
alimentadas com 3,3V. podem se adaptar para ser utilizados em
5V. e vice-versa.

RESET - pino conectado a pino de RESET do microcontrolador.

Pode ser utilizado para um reset externo da placa Arduino.

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.
Analisando os códigos
• A função setup () é executada na inicialização do programa e é
responsável pelas configurações iniciais do microcontrolador, tal
como definição dos pinos de I/O, inicialização da comunicação serial,
entre outras.
• A função loop () será onde ocorrerá o laço infinito da programação,
ou seja, onde será inserido o código que será executado
continuamente pelo microcontrolador.
Exemplo
Acender LED
ESQUEMA
ELÉTRICO
Lendo um pushbutton
Botão + LED Código

int ledPin = 13; // escolha o pino para o LED

int inPin = 2; // escolha o pino de entrada (para o interruptor)
int val = 0; // variável para ler o estado do interruptor

void setup() {
pinMode(ledPin, OUTPUT); // declara-se o LED como saída
pinMode(inPin, INPUT); // declara-se o interruptor como
entrada
}

void loop(){
val = digitalRead(inPin); // ler o valor de entrada
if (val == HIGH) { // verificar se a entrada é HIGH
(interruptor livre)
digitalWrite(ledPin, LOW); // desligar LED
} else {
digitalWrite(ledPin, HIGH); // ligar LED
}
}
EXEMPLO SAÍDA PWM
O uso de um sinal PWM para variação do brilho de um
LED

O circuito possui um LED ligado ao pino 3 (PWM) com

seu devido resistor e um potenciômetro ligado à entrada
analógica 0. A ideia é controlar a intensidade do brilho do
LED através da variação do valor do potenciômetro.
Vejamos o sketch a seguir:
 1 /*
2 PWM
CÓDIGO 3
4
controla a luminosidade de um led conforme o valor do potenciometro
*/
5
6 int ledPin = 3; // pino do led
7 int analogPin = 0; // pino para leitura do potenciômetro
8 int val = 0; //variável para armazenar o valor lido
9
1 void setup()
0 {
1 pinMode(ledPin, OUTPUT); // configura pino como saída
1 }
1
2 void loop()
1 {
3 val = analogRead(analogPin); // le o valor analógico
1 analogWrite(ledPin, val / 4); // aciona led com o valor analógico lido
4 //dividido por 4 para ajustar ao valor
1 //máximo que pode ser atribuído a função
5 }
1
6
1
7
1
8
1
9
2
0
2
1
Comunicação serial

A comunicação serial (UART) na

plataforma Arduino é, sem duvida,
um poderoso recurso que possibilita
a comunicação entre a placa e um
computador ou entre a placa e outro
dispositivo, como por exemplo um
módulo GPS ou um módulo GSM. É
através desse canal que é realizado
o upload do código para a placa.
Esse canal está ligado aos pinos
digitais 0 (RX) e 1 (TX). Esses mesmos
pinos estão ligados ao
microcontrolador ATMEGA16U2,
responsável pela tradução do sinal
para comunicação USB com o
computador.
E/S Analógicas
As entradas digitais só podem assumir dois estados,
HIGH e LOW, ou seja, 0 V ou 5 V
 Exemplo
Ligação em Arduino UNO
O exemplo a seguir lê o valor no potenciômetro. O tempo que o LED permanece ligado ou
desligado depende do valor obtido pelo analogRead().
/*
* Entrada analógica
* Liga e desliga um LED conectado ao pino digital 13. O tempo
* que o LED permanece ligado ou desligado depende do valor
* obtido pelo analogRead().
*/

int potPin = 0; // selecione o pino de entrada ao potenciômetro

int ledPin = 13; // selecione o pino ao LED
int val = 0; // variável a guardar o valor proveniente do sensor

void setup() {

pinMode(ledPin, OUTPUT); // declarar o pino ledPin como saída

void loop() {

val = analogRead(potPin); // ler o valor do potenciômetro

digitalWrite(ledPin, HIGH); // ligar o led

delay(val); // espera tempo ajustado no potenciometro
digitalWrite(ledPin, LOW); // desligar o led
delay(val); // espera tempo ajustado no potenciometro

}
 Entradas digitais
A placa Arduino UNO possui 14 pinos que podem ser configurados como
entrada ou saídas digitais conforme a necessidade de seu projeto. Estes
pinos são numerados de 0 a 13
 Entradas digitais
Para exemplificar a utilização de pinos de I/O digitais, vamos desenvolver uma aplicação de leitura de
tecla e acionamento de LED, conforme o a montagem feita

/*
Leitura de tecla
O exemplo le uma tecla conectada ao pino 2 e aciona um led conectado ao pino 13
*/

const int ledPin = 13; // cria uma constante com o numero do pino ligado ao LED
const int inputPin = 2; // cria uma constante com o numero do pino conectado a tecla

void setup()
{
pinMode(ledPin, OUTPUT); // declara o pino do led como saída
pinMode(inputPin, INPUT); // declara o pino da tecla como entrada
}

void loop()
{
int val = digitalRead(inputPin); // le o valor na entrada
if (val == LOW) // se valor está em zero( tecla pressionada)
{
digitalWrite(ledPin, HIGH); // Liga LED indicando tecla pressionada
}
else
{
digitalWrite(ledPin, LOW); // Desliga LED indicando tecla solta
}
}
Monitor Serial
Funções mais usadas com a placa
Arduino UNO

• Serial.begin()

• É a primeira função a ser utilizada quando vai trabalhar com a comunicação

serial. Ela configura a taxa de comunicação em bits por segundo (baud
rate). Possui um segundo parâmetro opcional para a definição da
quantidade de bits, paridade e stop bits. Se for omitido esse parâmetro o
padrão será 8 bits, sem paridade e 1 stop bit.
• Sintaxe:
• Serial.begin(speed)
• Serial.begin(speed, config)
• Retorno
Essa função não retorna nada.
Serial.available()
• Retorna a quantidades de bytes disponíveis para leitura no buffer de leitura. Essa
função auxilia em loops onde a leitura dos dados só e realizada quando há dados
disponível. A quantidade máxima de bytes no buffer é 64.

• Sintaxe:
• Serial.available();

• Parâmetros:
• Não passa nenhum parâmetro.

• Retorno:
• (int) - quantidade de bytes disponíveis para leitura