Introdução a Sistemas Embarcados com Arduino - mini-curso

v. 2 - 2014
Introdução a
Sistemas Embarcados
com Arduino
Felipe Nascimento Martins

O trabalho Introdução ao Arduino de Felipe Nascimento Martins foi
licenciado com uma Licença
Creative Commons - Atribuição-CompartilhaIgual 3.0 Não Adaptada.
Introdução a
Sistemas Embarcados
com Arduino

Contato:
Twitter: @f_n_martins
http://www.facebook.com/felipenm
felipe.n.martins@gmail.com

Conteúdo
• Sistemas embarcados;
• Arduino: características de hardware;
• Arduino: características de software;
• Microcontrolador;
• Eletrônica: conceitos básicos;
• Planejamento de programas;
• Sensores e atuadores;
• Práticas (montagem e programação);
• Avançando com o Arduino: shields, comunicação
sem fio, aplicações em robótica...

Sistemas Embarcados

Sistema Embarcado
• Sistema baseado em microcontroladores em
que o computador é encapsulado e dedicado
ao dispositivo ou sistema que ele controla;
• Realiza um conjunto de tarefas pré-definidas,
com requisitos específicos;
• Além do computador dedicado, em geral
possui sensores, atuadores e uma interface
com o usuário.

Sistema de Controle Embarcado

Exemplos de Sistemas Embarcados
• MP3 player, relógio digital, calculadora,
controlador de veículo elétrico, navegador
com GPS, leitora para pagamento com
cartões de crédito, robô, semáforo, roteador,
console de vídeo game, lavadora de roupas,
marca-passo, quadricóptero, forno de micro-
ondas, tablet, medidor de pressão arterial,
televisão etc.

O que é Arduino?
• Arduino é uma plataforma de prototipagem
eletrônica open-source, baseada nos princípios
de flexibilidade e facilidade de uso para hardware
e software.
• Consiste de uma placa com microcontrolador
programável preparada para receber sinais de
sensores e acionar atuadores.
• Sua linguagem de programação é baseada em
Wiring (baseado em C/C++).
• A placa pode funcionar em conjunto ou de forma
independente do computador.

Arduino – hardware

Arduino é Open Source
• Desenvolvido por: Massimo Banzi, David
Cuartielles, Tom Igoe, Gianluca Martino e David
Mellis, na Itália, em 2005;
• Todo o projeto é aberto: open source hardware
and software;
• 200 placas vendidas em 2005, 5.000 em 2006,
30.000 em 2007 e mais de 300.000 em 2011 e
cerca de 1 milhão até setembro de 2013!
• Site oficial: www.arduino.cc

Arduino é Open Source!

• Todo o hardware é aberto e os projetos estão
disponíveis.
• Quem quiser, pode comprar os componentes e montar a
sua placa!
• O software de programação também é livre e está
disponível para download gratuitamente.

disponíveis.
sua placa!
• Mas...

disponíveis.
sua placa!
• Mas...
• O nome Arduino é marca registrada!

Clones do Arduino
• Freeduino

Clones do Arduino
• Seeduino

Clones do Arduino
• Brasuíno

Clones do Arduino
• Severino

Similares ao Arduino
• chipKIT Uno32 - PIC32MX320F128 (32 bits,
80MHz, 128kB Flash, 16kB SRAM)

• Olimexino – STM32F103RBT6 (núcleo ARM Cortex
M3, 32 bits, 128kB, 72MHz)

• Adafruit Trinket – ATtiny85

• TI LaunchPad:
MSP430

• LaunchPad:
ARM Cortex M4

Compatível com Arduino

Características de Hardware

Arduino Uno
• Microcontrolador: ATmega328;
• Tensão de operação: 5V;
• Tensão de entrada (recomendada): 7-12V;
• Pinos digitais de E/S:14 (6 podem ter sinal PWM);
• Pinos com entrada analógica: 6;
• Corrente máxima por pino de E/S: 40 mA;
• Hardware para comunicação: 1 porta serial (UART TTL),
I2C (TWI), SPI;
• Memória Flash (de programa): 32 kB, dos quais 0,5 kB
são usados pelo bootloader;
• Memória SRAM: 2 kB; EEPROM: 1 kB;
• Frequência de clock: 16 MHz.

Arduino Leonardo
• Microcontrolador: ATmega32u4;
• Pinos digitais de E/S: 20 (7 podem ter sinal PWM);
• Hardware para comunicação: 1 porta serial (UART TTL),
I2C (TWI), SPI, USB 2.0 (emula teclado ou mouse);
• Memória Flash (de programa): 32 kB, dos quais 4 kB são
usados pelo bootloader;
• Memória SRAM: 2,5 kB; EEPROM: 1 kB;

Arduino Mega 2560
• Microcontrolador: ATmega2560;
• Pinos digitais de E/S: 54 (15 podem ter sinal PWM);
• Hardware para comunicação: 4 portas seriais (UART
TTL), I2C (TWI), SPI, USB 2.0 (emula teclado ou mouse);
• Memória Flash (de programa): 256 kB, dos quais 8 kB
são usados pelo bootloader;
• Memória SRAM: 8 kB; EEPROM: 4 kB;

Arduino Mega 2560

Microcontrolador

O que é um Microcontrolador?
– Chip;
– CPU de pequeno porte, capaz de executar
um conjunto de instruções;
– Ou seja, possui um microprocessador!
– Instruções simples e rápidas;
– Possui memória(s);
– Possui periféricos;
– Pode se comunicar com outros periféricos;
etc.

Componentes de um Microcontrolador
Conversor
D/A
Conversor
A/D
PWM
CPU
EEPROM
RAM
Porta
Serial
Porta
Paralela
Temporizadores
Microcontrolador

Diagrama de blocos da arquitetura

Exemplos de Microcontroladores
• Família 8051 (Intel ou ATMEL)
• 80C196KB (Intel)
• 68HC11 (Motorola / Freescale)
• MSP430 (Texas Instruments)
• ATmega328 (ATMEL)
• PIC16F628A (Microchip)
• dsPIC30F6014 (Microchip)
• Cortex M3 (ARM)

Exemplos de Microcontroladores
• Família 8051 (Intel ou ATMEL)
• 80C196KB (Intel)
• 68HC11 (Motorola / Freescale)
• MSP430 (Texas Instruments)
• ATmega328 (ATMEL)
• PIC16F628A (Microchip)
• dsPIC30F6014 (Microchip)
• Cortex M3 (ARM)
Cadê o
Arduino??

• ATMEL
• ATmega168: Diecimila, Duemilanove, Nano,
LilyPad;
• ATmega328P: Duemilanove, Nano, Fio, LilyPad,
Uno;
• ATmega1280: Mega;
• ATmega2560: Mega2560;
• ATmega32u4: Leonardo, Esplora, LilyPad USB,
Yún, Robot;
• AT91SAM3X8E: Due.
Microcontroladores do Arduino

Arduino Processador
Flash
kB
EEPROM
kB
SRAM
kB
Dig.
I/O
Pinos
A/D
Clock
(MHz)
Pinos
PWM
Duemilanove ATmega168/328P 16/32 0,5/1 0,5 14 6 16 6
Uno ATmega328P 32 1 2 14 6 16 6
Mega ATmega1280 128 4 8 54 16 16 15
Mega2560 ATmega2560 256 4 8 54 16 16 15
Nano
ATmega168 ou
ATmega328
16/32 0,5/1 0,5 14 8 16 6
LilyPad
ATmega168V ou
ATmega328V
16/32 0,5 1 14 6 16 6
Leonardo ATmega32u4 32 1 2,5 20 12 16 7
Due AT91SAM3X8E 512 -- 96 54 12 84 12
Esplora ATmega32u4 32 1 2,5 20 12 16 7
Arduino

Arduino - Microcontrolador

• ATmega328 (Arduino Uno):
• Núcleo AVR RISC de 8 bits;
• 32kB Flash, 2kB RAM, 1kB EEPROM;
• 23 pinos de E/S;
• 3 temporizadores/contadores;
• USART, I2C, interface a 2 fios SPI;
• 6 canais de conversor A/D de 10 bits;
• WDT com oscilador interno;
• Clock máximo de 20MHz;
• Opera de 1,8V a 5,5V.

• ATmega32u4 (Arduino Leonardo):
• Núcleo AVR RISC de 8 bits;
• 32kB Flash, 2kB RAM, 1kB EEPROM;
• 26 pinos de E/S;
• 3 temporizadores/contadores;
• USART, USB transceiver, I2C, 2 interfaces a 2 fios SPI;
• 12 canais de conversor A/D de 10 bits;
• WDT com oscilador interno;
• Clock máximo de 16MHz;
• Opera de 2,7V a 5,5V.

Características de Software

Arduino – Programação

Arduino – Programação
Programa.HEXCompilador
Programador
IDE

Arduino – Programa básico

Arduino – Programa básico
No Arduino Uno:
pinos digitais 0 a 13 (0 a 13);
pinos analógicos 0 a 5 (14 a 19).

Prática 1: Pisca-LED
• Montagem:

Matriz de contatos (Breadboard ou Protoboard)

http://123d.circuits.io/circuits/155964-pratica-1-pisca-led/embed
Prática 1: Pisca-LED

Eletrônica:
Conceitos Básicos

Um pouco de eletrônica
• Ok. Entendi o programa.
• Mas o que acontece nos
pinos do Arduino?

pinos do Arduino?
• A função
digitalWrite(12,HIGH);
faz com que o pino 12 vá
para “nível alto”, ou seja,
ele fica com 5V.

pinos do Arduino?
• A função
ele fica com 5V.
• Este pino está ligado ao
RESISTOR+LED, e ao pino
GND (0V).

pinos do Arduino?
• A função
ele fica com 5V.
• Este pino está ligado ao
RESISTOR+LED, e ao pino
GND (0V).
• É um circuito série, por
onde circula corrente!
+5V
0V

• Em resumo:
• É a circulação de corrente
elétrica (elétrons) que faz
acender o LED;
• Experimente retirar o fio
que liga o LED ao GND,
mantendo o pino 12 em 5V.
• O LED apaga pois a
corrente precisa circular
num circuito fechado!
+5V
0V

• Em resumo:
• É a circulação de corrente
elétrica (elétrons) que faz
acender o LED;
• A corrente só existirá se
houver diferença de
potencial elétrico
(diferença de tensão) entre
pontos do circuito: 5V – 0 =
5V;
• Tensão: volt [V];
• Corrente: ampère [A].
+5V
0V

• A função
digitalWrite(12,LOW);
para “nível baixo”, ou seja,
ele fica com 0V.
• Logo, como não há
diferença de tensão entre
os pinos 12 e GND, a
corrente é zero => LED
apaga.
0V
0V

• Beleza. Mas, e o resistor?
Serve para quê?

• Beleza. Mas, e o resistor?
Serve para quê?
• O elemento resistor serve
para dificultar a circulação
de corrente elétrica;
• Ele é colocado no circuito
para evitar que a corrente
cresça muito, o que pode
provocar problemas;
• No nosso circuito, o
resistor serve para evitar
que o LED queime devido
a uma corrente muito alta.

• Quanto maior for o valor
da resistência do resistor,
menor será a corrente
(para uma mesma
diferença de tensão).
• O brilho do LED varia com
a corrente.

• Cálculo da corrente:
• Lei de Ohm: V = R * I
• V = 5V, R = 220Ω.
• I = 5 / 220
• I = 0,0227 A = 22,7 mA

• Lei de Ohm: V = R * I
• V = 5V, R = 220Ω + 220Ω.
• I = 5 / 440
• I = 0,0114 A = 11,4 mA
• Podemos calcular a queda de
tensão em cada resistor:
• VR = R * I, R = 220Ω, I = 11,4 mA.
• VR = 220 * 0,0114 = 2,5 V.

• O LED tem queda de
tensão fixa = ~1,73V. Logo:
• V = 5 – 1,73 = 3,27V.
• V = R * I => I = V / R.
• I = 3,27 / 220 = 0,0149 A
• I = 14,9mA.
+5V
0V

• Note que se a tensão do
pino 12 pudesse ser
alterada, a corrente no
circuito seria diferente.
• Ou seja, poderíamos
controlar o brilho do LED!
+5V
0V

Prática 2: Código Morse
• Modifique o programa
Pisca-LED de forma que o
LED sinalize
indefinidamente o código
Morse que representa
S.O.S.:
...---...
OBS.: “ponto” é uma piscada
rápida do LED (pouco
tempo aceso), enquanto o
“traço” é uma piscada mais
lenta (mais tempo aceso).

Diodo
• Dispositivo semicondutor que permite a circulação de
corrente apenas em um sentido;
• A tensão em seus terminais deve ter polaridade correta:
mais positiva no terminal A (anodo) e mais negativa no
terminal K (catodo);
• Apresenta queda de tensão aproximadamente fixa
(~0,7V) quando a corrente circula;
• Usado em circuitos retificadores: transforma corrente
alternada para contínua.

Diodo
• Retificador de onda completa:

Diodo - exemplos

Prática 3: Não pisca-LED
• LED é um diodo especial
que brilha quando a
corrente circula por ele.
• Experimente inverter a
ligação dos pinos do LED
em nosso circuito e
verifique que ele não vai
mais piscar, mesmo
quando houver diferença
de potencial nos pinos!

Capacitor
• Elemento que armazena energia na forma de campo
elétrico;
• Existem vários tipos: alguns têm polaridade (como os
eletrolíticos), outros não (como os cerâmicos);
• A tensão em seus terminais depende da carga
acumulada, e não varia instantaneamente;
• Em corrente contínua, são usados como filtros ou
“suavizadores” de tensão.

Capacitor - exemplos

Capacitor – exemplo de aplicação
• Retificador de onda completa com capacitor:

Sensores Digitais

Sensores com Sinais Digitais
• Diversos sensores proveem informação através
de sinais digitais:
• Botão;
• Porta aberta/fechada;
• Andar de elevador;
• Fim-de-curso em máquinas industriais;
• Equipamento ligado/desligado;
• Nível de reservatório;
• Presença;
• Toque;
• Etc.

Sensores com Sinais Digitais
• Do ponto de vista elétrico, comportam-se como se
fossem uma chave liga/desliga;
• Nesses casos, podemos fazer a ligação de modo
que o sinal do sensor seja 0V ou 5V;
• No Arduino, a função utilizada para leitura de sinais
digitais é digitalRead(pino); onde pino é o
número do pino em que o sensor está ligado;
• Para Vs = 5V, retorna 0 (Vpino < 2V) ou 1 (Vpino > 3V).

Prática 4: Leitura de Sinal Digital
• Monte o circuito ao
lado.
• Altere o programa
da prática 1 para
que o LED acenda
com o botão for
pressionado, e
apague quando o
botão for liberado.

http://123d.circuits.io/circuits/155968-pratica-4-leitura-de-sinal-digital/embed

Programas mais complexos

Funções do Arduino
• Já vimos:
void setup(){
...
}
void loop(){
...
}

• Já vimos:
pinMode(pino, OUTPUT ou INPUT);
digitalWrite(pino, LOW ou HIGH);
delay(número inteiro);
digitalRead(pino);

• Outras funções:
delayMicroseconds(número inteiro);
Pausa o programa pela quantidade definida de
microssegundos.
millis();
Retorna o número de milissegundos que se passou
desde que o microcontrolador foi ligado.
analogRead(pino);
Obtém valor entre 0 e 1023 proporcional à tensão no
pino (entre 0 e 5V). Tempo de conversão = 100μs.

• Exemplos:
while(analogRead(A2) < 950){
... // bloco de código
}
Executa o bloco de código até que o valor de retorno
da função analogRead seja maior que 950.
for(int conta = 0; conta < 6; conta++){
... // bloco de código
}
Executa o bloco de código até que conta >= 6.

• Exemplos:
if (brilho == 0 || brilho == 255) {
... // bloco de código 1
}
else {
... // bloco de código 2
}
Executa o bloco de código 1 se a condição de teste
for verdadeira. Caso contrário, executa o bloco de
código 2.

Criando Funções no Arduino
int led = 13;
void setup(){
pinMode(led, OUTPUT);
}
void inverteLED(){
if (digitalRead(led)==0)
digitalWrite(led, HIGH);
else
digitalWrite(led, LOW);
}
void loop(){
inverteLED();
delay(500);
}

Tipos de Dados no Arduino
boolean (8 bits) – true/false;
byte (8 bits) – número entre 0 e 255;
char (8 bits) – caractere (número entre -128 e 127);
unsigned char (8 bits) – mesmo tipo que ‘byte’;
word (16 bits) – número entre 0 e 65.535;
unsigned int (16 bits) – mesmo tipo que ‘word’;
int (16 bits) – número entre -32.768 e 32.767;
unsigned long (32 bits) – número entre 0 e
4.294.967.295;
long (32 bits) – número entre -2.147.483.648 e
2.147.483.647;
float (32 bits) – entre -3,4028235E38 to 3,4028235E38.

Linguagem do Arduino

Planejamento de um Programa
• Fluxogramas

Planejamento de um Programa

Exercício: Desenhe o Fluxograma
const int ledPin = 13; // pino do LED
int ledState = LOW; // estado do LED
long previousMillis = 0; // última atualização do LED
long interval = 500; // interval para piscar LED
void setup() {
pinMode(ledPin, OUTPUT);
}
void loop(){
unsigned long currentMillis = millis();
if(currentMillis - previousMillis > interval) {
previousMillis = currentMillis;
if (ledState == LOW)
ledState = HIGH;
else
ledState = LOW;
digitalWrite(ledPin, ledState);
}
} Felipe Nascimento Martins

lado.
da prática 4 para
que o LED troque
de estado a cada
pressionar de
botão: se estiver
apagado, acende; e
vice-versa.

lado.
da prática 4 para
que o LED troque
de estado a cada
pressionar de
botão: se estiver
apagado, acende; e
vice-versa.
• Funcionou como
esperado?

Leitura de Sinal Digital

Bounce (oscilação de contato)

Técnica para fazer debounce do sinal

int led_pin = 13;
int led_state = LOW;
int button_pin = 0;
int button_state;
// the setup routine runs once when you press reset:
void setup() {
pinMode(led_pin, OUTPUT);
pinMode(button_pin, INPUT);
}
// the loop routine runs over and over again forever:
void loop() {
// Enquanto o botão não for pressionado, não faz nada.
while (digitalRead(button_pin)!=0){
}
// Depois que o botão é pressionado, aguarda ser solto
while (digitalRead(button_pin)==0){
}
// Atraso para aguardar oscilação de contato terminar
delay(50);
// Inverte o estado da variável led_state
led_state = !led_state;
// Copia variável led_state para o pino do LED
digitalWrite(led_pin, led_state);
}

Sensores Analógicos

Sensores com Sinais Analógicos
• Diversos sensores proveem informação através
de sinais analógicos:
• Intensidade luminosa (LDR);
• Deslocamento (angular ou linear);
• Força/Torque (SFR, strain gage);
• Proximidade;
• Aceleração;
• Inclinação;
• Temperatura;
• Etc.

Intensidade Luminosa: LDR
• Resistor cuja resistência varia conforme a
intensidade da luz incidente.
• Vários modelos com diferentes sensibilidades.
• Datasheet: http://www.biltek.tubitak.gov.tr/gelisim/elektronik/dosyalar/40/LDR_NSL19_M51.pdf

Intensidade Luminosa: LDR

Prática 6: Usando o sensor de luz
• Monte o circuito com LDR – Light Dependent
Resistor (sensor de luz).
• Escreva um programa que acenda o LED do pino
13 quando houver pouca luz e apague o mesmo
LED quando houver muita luz.
void setup() {
...
}
void loop() {
...
}

Deslocamento
• Deslocamento linear ou angular pode ser medido
com potenciômetros;
• Com alimentação de 5V, o sinal varia de 0 a 5V
(mínimo a máximo deslocamento);
• Há potenciômetros angulares multivoltas e
potenciômetros lineares de longo alcance.

Deslocamento

Força e Torque
• FSR (Force Sensing Resistor) e Strain Gage
(extensômetro): resistência varia com a
deformação.
• Usados para medir força e torque.
• Datasheets:
FSR - http://www.trossenrobotics.com/productdocs/2010-10-26-DataSheet-FSR402-Layout2.pdf
Célula de carga - http://www.alfainstrumentos.com.br/manuais/celulas/catalogo_celulas_0302cp.pdf

Strain Gage

Proximidade por infravermelho
• Sharp GP2Y0A21YK0F
• Tensão de alimentação: 5V;
• Pode medir distâncias de 10 a 80 cm;
• Sinal: tensão entre 1,65V e 2,15V.
• Há outros modelos com outras faixas de medição.
Datasheet: https://www.sparkfun.com/datasheets/Components/GP2Y0A21YK.pdf

Proximidade por infravermelho

Aceleração/Inclinação
• ADXL335
• Tensão de alimentação: 3,3 V;
• Mede aceleração nos 3 eixos do espaço;
• Mede aceleração de até 3g;
• Mede aceleração da gravidade (estática),
podendo ser usado para medir inclinação.
• Datasheet: https://www.sparkfun.com/datasheets/Components/SMD/adxl335.pdf

Temperatura: RTDs
• RTD = Resistance Temperature Detectors
• Normalmente confeccionados com um fio (ou
enrolamento) de alta pureza de cobre, níquel ou
platina (estes são os melhores).
• RTDs comuns podem medir com erros da ordem de
±0,1ºC. Os de platina (PRT – Platinum Resistance
Thermometer) podem chegar a ±0,0001ºC.
• São estáveis e lineares, com ótima repetitividade.
• Aplicações incluem refrigeração de alimentos e
compostos químicos, fornos de fusão (produção de
metais e ligas), destilação fracionada (produção de
bebidas e derivados de petróleo), usinas nucleares e
aquecedores e refrigeradores domésticos.

Temperatura: Termistores NTC/PTC
• São semicondutores cerâmicos que têm sua
resistência alterada com a variação de temperatura.
• Geralmente seu coeficiente de variação é maior que o
dos RTDs, mas a variação de resistência é menos
linear.
• Podem ser de dois tipos: NTC ou PTC (Negative ou
Positive Temperature Coefficient).
• Faixa típica de operação: de -100ºC a 300ºC.
• Resistência a 25ºC: de 0,5Ω a 100MΩ.
• Aplicações: circuitos simples de medição de
temperatura; para reduzir corrente de carga de
capacitores em fontes chaveadas (NTCs) etc.

Temperatura: RTD ou NTC

Temperatura: TMP35/36/37
• Tensão de alimentação: 2,7 V a 5,5 V;
• Fator de escala: 10 mV/°C;
• Precisão: ±2°C;
• Linearidade: ±0,5°C;
• Faixa de operação: −40°C a +125°C.
• Datasheet: http://dlnmh9ip6v2uc.cloudfront.net/datasheets/Sensors/Temp/TMP35_36_37.pdf

Temperatura: TMP35/36/37

Comunicação Serial

Comunicação serial
• Bit: menor unidade de informação -> 0 ou 1;
• Informação é enviada bit a bit, em sequência;
• Síncrona: uma linha de dados e outra de clock:

• Bit: menor unidade de informação -> 0 ou 1;
• Informação é enviada bit a bit, em sequência;
• Assíncrona: apenas uma linha de dados. A
velocidade deve ser definida:

• OK.
• Mas como posso transmitir outras informações
além de “zeros” e “uns”?

• OK.
• Mas como posso transmitir outras informações
além de “zeros” e “uns”?
• Existe uma tabela que relaciona caracteres a
sequências de zeros e uns:
• ASCII (American Standard Code for
Information Interchange).
• Esta tabela criou um padrão para troca de
informações em sistemas binários.

Comunicação Serial no Arduino
• Microcontrolador possui hardware para
comunicação serial:
• Pino digital 0 (RX): recepção de dados;
• Pino digital 1 (TX): transmissão de dados;
• Bit 1 = 5V; Bit 0 = 0V;
• A maioria das placas Arduino possui hardware
que converte sinais do padrão serial assíncrono
para USB;

Prática 7: Medindo Temperatura
• Monte o circuito com o sensor de temperatura.
• Escreva um programa que mostre o valor da
temperatura na tela do computador a cada 0,5s.

• Exemplo de programa:
void setup() {
Serial.begin(9600);
}
void loop() {
int sensor = analogRead(A0);
Serial.println(sensor);
delay(500);
}

http://123d.circuits.io/circuits/155990-pratica-7-medindo-temperatura-sinal-analogico/embed

• Serial.println(analogValue, DEC); //
envia analogValue (int) codificada em
ASCII no formato decimal
• Serial.println(analogValue, HEX); //
envia ASCII no formato hexadecimal
• Serial.println(analogValue, OCT); //
envia ASCII no formato octal
• Serial.println(analogValue, BIN); //
envia ASCII no formato binário

• Serial.available(); // retorna 1 se
houver caracter disponível no buffer de
recepção. Caso contrário, retorna 0.
• Serial.read(); // lê um byte recebido
pela Serial (int)
• Exemplo:
int incomingByte;
if (Serial.available() > 0) {
incomingByte = Serial.read();
}

Prática 8: Comunicação bidirecional
• Outro exemplo de comunicação serial: desta vez
o Arduino vai receber um dado do computador,
processá-lo e retornar o resultado pela porta
serial.
• Vamos analisar o programa:
int i, numero;
void setup() {
Serial.begin(9600);
}
void loop() {
while (true) {
Serial.print("Entre com um numero: ");
while (Serial.available()==0);
numero = Serial.read();

if (numero>='0' && numero<='9')
Serial.println(numero-’0’);
else {
Serial.println("O valor deve ser numerico!");
continue;
}
numero-='0';
for (i = 0; i <= 10; i++) {
Serial.print(numero);
Serial.print(" x ");
Serial.print(i);
Serial.print(" = ");
Serial.println(numero*i);
}
Serial.println("");
}
}

Prática 8: Comunicação bidirecional
http://123d.circuits.io/circuits/155997-pratica-8-comunicacao-bidirecional-tabuada/embed

Mais um pouco
de Eletrônica

Shift Registers
• Shift registers (ou Registradores de
Deslocamento) são memórias que recebem
uma sequência de bits enviados serialmente e
disponibilizam seus valores de forma
simultânea;
• Muito utilizados em sistemas embarcados
para economizar pinos de E/S dos
microcontroladores;
• CI 74HC595 é um shift register de 8 bits.
• Datasheet: http://arduino.cc/en/uploads/Tutorial/595datasheet.pdf

Shift Registers
74HC595

Prática 9: Usando shift register
• Monte o circuito abaixo.

int latchPin = 8; //Pin connected to ST_CP of 74HC595
int clockPin = 12; //Pin connected to SH_CP of 74HC595
int dataPin = 11; //Pin connected to DS of 74HC595
void setup() {
//set pins to output so you can control the shift
register
pinMode(latchPin, OUTPUT);
pinMode(clockPin, OUTPUT);
pinMode(dataPin, OUTPUT);
}

void loop() {
// count from 0 to 255 and display the number
for (int numberToDisplay = 0; numberToDisplay < 256;
numberToDisplay++) {
// take the latchPin low: LEDs don't change
digitalWrite(latchPin, LOW);
shiftOut(dataPin, clockPin, MSBFIRST,
numberToDisplay);
digitalWrite(latchPin, HIGH); // turn LEDs on
delay(500);
}
}

Controle de cargas analógicas

“Simulando” uma tensão analógica
• PWM = Pulse Width Modulation;
• Razão cíclica (duty cycle): define a tensão
média aplicada:
T(PWM) T(PWM) T(PWM)
A1 A2 A3

Tensão média de um sinal PWM

Sinal PWM versus sinal analógico

Controle de potência por PWM
 P = V2 / R
analogWrite(11, 200);
 cria no pino 11 um sinal
PWM com razão cíclica
igual a 200;
 f = 490Hz;
 apenas alguns pinos
possuem saída PWM.

Prática 10: Controle de brilho
int brilho = 0; // brilho do LED
int sensor; // valor do LDR
void setup() {
pinMode(A2, INPUT); // pino do LDR: entrada A2
pinMode(13, OUTPUT); // pino do LED: saida 13
Serial.begin(9600);
}
void loop() {
sensor = analogRead(A2); // le valor do LDR
brilho = map(sensor, 0, 1023, 0, 255);
Serial.println(brilho); // envia ao PC
analogWrite(13, brilho); // aciona LED
delay(100);
}

Prática 11: Pisca-pisca suave
int brilho = 0; // brilho do LED
int variacao = 5; // quanto varia o brilho
void setup() {
pinMode(13, OUTPUT);
}
void loop() {
analogWrite(13, brilho);
brilho = brilho + variacao;
if (brilho == 0 || brilho == 255) {
variacao = -variacao;
}
delay(30);
}

Módulo LCD

LCD – Liquid Cristal Display
• Opção prática de apresentar uma grande
quantidade de dados de forma relativamente
simples e barata;
• O módulo é constituído de um display de
cristal líquido (LCD) e de um controlador de
display;
• Existem dois tipos de módulo LCD: caractere
e gráfico.

• Os displays de caracteres são mais baratos e
capazes de apresentar caracteres como
letras, números e símbolos;
• Sua tela é dividida em linhas e colunas, e
cada posição armazena um caractere;
• Não funcionam adequadamente para a
apresentação de gráficos.

• Os displays gráficos são mais caros e
complexos de programar;
• Podem apresentar basicamente qualquer tipo de
informação na tela, inclusive gráficos, fotos etc.
100 x 64 pixels 128 x 64 pixels

• Serão abordados neste curso os módulos de
caractere baseados no chip controlador
Hitachi HD 44780;
• É um chip que é praticamente padrão no
segmento de módulos de display LCD;
• Permite um interface simples com
microcontroladores.

• Tem largura de barramento de dados
selecionável para 4 ou 8 bits;
• São necessárias três linhas de controle
adicionais: ENABLE, RS e R/W;
• A comunicação no modo de 4 bits é realizada
utilizando apenas as quatro linhas mais
significativas (D7 a D4). O byte é dividido em
dois nibbles onde o mais significativo é enviado
primeiro.

Bit 1 de dados do LCDD18
EnableE6
Read/WriteR/W5
Register SelectRS4
ContrasteVo3
Positivo (5V)Vdd2
TerraVss1
FunçãoNomePino

Catodo do back-light (se existir)K16
Anodo do back-light (se existir)A15
FunçãoNomePino

• O HD 44780 possui as seguintes memórias:
– 80 bytes de memória RAM (DDRAM – Data
Display RAM);
– 64 bytes de RAM para o gerador de
caracteres (CGRAM – Caracter Generator
RAM);
– 9920 bits de memória ROM (CGROM): 208
caracteres 5x8 ou 32 caracteres 5x10.

• O Arduino possui uma biblioteca para
utilização de LCDs de caractere;
• Após incluir a biblioteca, é necessário
declarar o display informando a que pinos do
Arduino o LCD está conectado;
• Em seguida, deve ser chamada a função de
inicialização, passando como parâmetros o
número de caracteres e de linhas que o LCD
possui.

Prática 12: Dados no LCD
#include <LiquidCrystal.h>
// inicializa bib. informando os pinos conectados:
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup() {
lcd.begin(16, 2); // inicializa o LCD
lcd.print("hello, world!"); // mostra mensagem
}
void loop() {
// coloca cursor na coluna 0, linha 1:
lcd.setCursor(0, 1);
// mostra numero de segundos desde o reset:
lcd.print(millis()/1000);
delay(100);
}

Prática 12: Dados no LCD

• Outras funções interessantes:
lcd.home(); // retorna cursor ao início
lcd.write(char); // imprime um caracter
lcd.blink(); // aciona cursor piscante
lcd.noBlink(); // desliga cursor piscante
lcd.autoscroll(); // ativa deslocamento a esquerda
lcd.noAutoscroll(); // desliga deslocamento
lcd.noDisplay(); // apaga tela (texto na memória)
lcd.display(); // liga tela (exibe caracteres)
lcd.rightToLeft(); // próxima letra à esquerda
lcd.leftToRight(); // próxima letra à direita
lcd.clear(); // limpa a tela

Prática 13: Valor do sensor no LCD
• Modifique o programa anterior para fazer com que a
primeira linha do LCD mostre o valor de temperatura
e a segunda linha mostre um relógio tipo HH:MM:SS.

LCD gráfico 128 x 64 pixels
Detalhes: http://nossosrobos.blogspot.com.br/2012/01/lcd-para-seu-robo-com-arduino.html

Avançando com Arduino e
Sistemas Embarcados

Motores Elétricos

Motor de Corrente Contínua (CC)
• Alimentado em corrente contínua;
• Possui ímã e bobinas internamente;
• Velocidade é ajustada pela tensão de
alimentação (pode ser por PWM!);
• Sentido de giro é alterado pela polaridade.

Motor de Passo
• Alimentado com sinais
digitais;
• Alimentação das
bobinas deve ser
sequencial;
• Permite controle preciso
de posição;
• Torque cai muito com o
aumento da velocidade.

Medição de deslocamento (encoder)
• Permite medir a velocidade e posição angular
dos motores;
• Precisão: número de pulsos por volta.

Medição de deslocamento (encoder)

Servomotor
• É um motor CC que possui um sistema de
interno de medição e de controle:
• angular – controla a posição (giro) do eixo;
• contínuo – controla a velocidade do eixo;

Servomotor

Servomotor
• Normalmente é feito com um motor de
corrente contínua, um circuito eletrônico e
engrenagens para aumentar o torque;

Servomotor
• Três fios: 2 de alimentação e um de controle;
• O sinal de referência (de posição ou
velocidade) é do tipo PWM.

Exemplo: Controle de Servomotores

#include <Servo.h>
Servo myservo; // create servo object
Servo myservo2;
int potpin = 0; // used to connect the potentiometer
int val; // value from the analog pin
void setup() {
myservo.attach(9); // attaches the servo on pin
myservo2.attach(10);
}
void loop() {
val = analogRead(potpin); // entre 0 e 1023
val = map(val, 0, 1023, 0, 179); // escalona
myservo.write(val);
myservo2.write(179-val);
delay(15);
} Felipe Nascimento Martins

Outros motores com Arduino
• Cada pino do Arduino pode fornecer, no máximo,
40mA de corrente -> pode não ser suficiente para
acionar um motor!
• Solução: usar transistores.

Transistor
• Um transistor pode ser entendido
como uma “válvula” eletrônica: é
capaz de acionar cargas de alta
corrente a partir de um sinal de
controle de baixa corrente.
• Quanto maior for a corrente no pino
de “base” (B), maior será a corrente
entre os pinos “coletor” (C) e “emissor”
(E).
• Por exemplo, se a corrente na base
variar de 0 a 0,01 A, a corrente de
coletor pode variar de 0 a 1A!

Exemplo: Motor CC com transistor

• Com um transistor é possível ligar e desligar um
motor, além de controlar sua velocidade (PWM);
• Mas, para inverter o sentido de giro de um motor
CC é necessário inverter o sentido de circulação
da corrente no motor;
• Com um transistor, a corrente circula apenas num
sentido;
• Solução: usar quatro transistores conectados em
forma de ponte: Ponte H.
Ponte H

Ponte H

Ponte H – exemplo

Motor Shield oficial
• Shield oficial para controle de motores: circuito
integrado com ponte H.

Motor Shield
• Pode acionar dois motores CC ou um motor de
passo: até 36V, 600mA, 5kHz.

Motor Shield
• Exemplo: controle de velocidade dos motores
com o Shield Motor Control:

• Pode acionar quatro
motores CC (46V, 4A) e
uma carga resistiva de até
30A.
Motor Shield 4 Power

Conectando Dispositivos

• A maioria das placas Arduino possui hardware
para implementação de comunicação serial em
diferentes padrões:
• SPI – Serial Peripheral Interface;
• TWI – Two Wire serial Interface (I2C);
• USART – Universal Synchronous and
Asynchronous serial Receiver and
Transmitter (estilo RS-232) – Já vimos este
tipo;

SPI – Serial Peripheral Interface

SPI
• SPI – Serial Peripheral Interface – é uma
interface de comunicação serial síncrona
utilizada para comunicação a curta distância:
• CIs conversores A/D e D/A;
• Memórias Flash e EEPROM;
• Relógios de tempo real;
• Sensores;
• Potenciômetros digitais;
• Telas de LCD; etc.

SPI
• Na comunicação SPI sempre existe um
dispositivo mestre (em geral é o próprio
microcontrolador) que controla os periféricos;
• Três linhas são comuns a todos os dispositivos:
– MISO (Master In Slave Out) – linha pela qual o
escravo envia dados ao mestre;
– MOSI (Master Out Slave In) – linha pela qual o
mestre envia dados aos escravos;
– SCK (Serial Clock) – clock gerado pelo mestre
para sincronizar a comunicação.

SPI
• Além das linhas MISO, MOSI e SCK, cada
dispositivo está conectado a uma linha SS:
• SS (Slave Select) – cada escravo possui uma
entrada desta linha, que é controlada pelo
mestre para habilitar ou desabilitar os
dispositivos individualmente:
• Em nível baixo: comunicação habilitada;
• Em nível alto: escravo ignora o mestre.

SPI com vários escravos

SPI com Arduino
• A biblioteca do Arduino faz a placa operar em
modo mestre;
• Ordem de transmissão dos dados (primeiro pelo
MSB ou pelo LSB): SPI.setBitOrder()
• Linha de clock fica em nível alto ou baixo
quando inativa e modo de amostragem de
dados: SPI.setDataMode()
• Velocidade de comunicação:
SPI.setClockDivider()

Cartão de Memória SD

• A biblioteca “SD.h” provê meios de
utilização de cartões de memória SD com o
Arduino.
• Esse tipo de memória se comunica com o
microcontrolador por SPI.

Alimentação: 3,3V  uso de resistores em 5V!

Exemplo: data logger
#include <SD.h>
const int chipSelect = 4;
void setup()
{
Serial.begin(9600);
Serial.print("Initializing SD card...");
pinMode(10, OUTPUT); // chip select
if (!SD.begin(chipSelect)) {
Serial.println("Card failed, or not present");
return;
}
Serial.println("card initialized.");
}

void loop()
{
// make a string for assembling the data to log:
String dataString = "";
// read three sensors and append to the string:
for (int analogPin = 0; analogPin < 3;
analogPin++) {
int sensor = analogRead(analogPin);
dataString += String(sensor);
if (analogPin < 2) {
dataString += ",";
}
}

// open the file. only one file can be open at a
time,
File dataFile = SD.open("datalog.txt", FILE_WRITE);
// if the file is available, write to it:
if (dataFile) {
dataFile.println(dataString);
dataFile.close();
// print to the serial port too:
Serial.println(dataString);
}
// if the file isn't open, pop up an error:
else {
Serial.println("error opening datalog.txt");
}
}

TWI – Two Wire serial Interface
(I2C)

I2C
• I2C (Inter-Integrated Circuit) foi desenvolvido
pela PHILIPS no início da década de 1980 para
transferência de dados entre
microcontroladores e equipamentos;
• Barramento de comunicação serial de dados
entre dispositivos onde a conexão é feita
através de 2 fios;
• É half-duplex, ou seja, em determinado
instante, apenas recebe ou envia informação;

I2C
• Taxa de transferência: até 100kbits/s;
• Operação em modo mestre/escravo: um
dispositivo ou processo (mestre) tem controle
unidirecional sobre um ou mais outros
dispositivos (escravos);
• Pode possuir mais de um mestre, mas só um
controla o barramento de cada vez.

I2C
• Um fio transporta o sinal do clock (SCL – Serial
Clock Line) e o outro, os dados (DAS - Serial
Data Line);
• A comunicação é síncrona. Primeiro é enviado o
endereço do dispositivo destinatário. Em
seguida, o dado é enviado ao barramento.

TWI (I2C)
• No Arduino a biblioteca Wire possui as funções
para implementação da comunicação I2C;
• Esta biblioteca implementa apenas
endereçamento de 7 bits;
• Caso use dispositivos que exijam 8 bits de
endereçamento, deve-se configurar seu
endereço para a faixa 0-127.

TWI (I2C)

Exemplo: Potenciômetro Digital
#include <Wire.h>
void setup() {
Wire.begin(); // join i2c (address optional for master)
}
byte val = 0;
void loop() {
Wire.beginTransmission(44); // transmit to device #44
// device address is specified in datasheet
Wire.write(byte(0x00)); // sends instruction byte
Wire.write(val); // sends potentiometer value byte
Wire.endTransmission(); // stop transmitting
val++; // increment value
if(val == 64) { // if reached 64th position (max)
val = 0; // start over from lowest value
}
delay(500);
}

Arduino e NXT via RS-485 e I2C
Arduino Nano

Arduino e NXT via RS-485 e I2C
Detalhes: http://nossosrobos.blogspot.com.br/2011/08/arduino-conversando-com-nxt-via-rs-485.html
http://nossosrobos.blogspot.com.br/2013/03/comunicacao-ic-entre-lego-nxt-e-arduino.html

Comunicação Serial USART:
Meios de Utilização

Comunicação sem-fio
• Wixel shield for Arduino, com dois módulos Wixel;
• Rádio de 2,4GHz para até 30 metros, 350kbps;
• Possui microcontrolador programável por interface
amigável;
• Tem 15 pinos de I/O, com 6 entradas analógicas, que
podem ser programados de forma independente da
comunicação;
• Permite a criação de uma rede com até 128 módulos de
comunicação;
• A comunicação é feita como se fosse comunicação
serial padrão;
• Permite gravar programas no Arduino sem ligar o cabo
USB à placa!

Comunicação sem-fio
http://nossosrobos.blogspot.com.br/2011/12/arduino-wireless.html

Conexão Bluetooth
• Modelo JY-BT03 - Shenzhen Jiayuan Electronic Co. Ltd.;
• Conexão com pinos RX-TX do microcontrolador;
• Comunicação Bluetooth 2.0;
• Baud rate: 2.400 a 1.382.400 bps;
• Tensão de alimentação: 5,0 V (3,6V a 6,0V);
• Corrente: 35mA quando realiza "pareamento"; 8mA
quando conectado;
• Antena impressa na própria placa;
• Possui LED que indica o estado da conexão Bluetooth;
• Senha padrão: 1234.

Detalhes: http://nossosrobos.blogspot.com.br/2012/05/arduino-wireless-parte-ii-via-bluetooth.html
Conexão Bluetooth

Conexão Bluetooth
Detalhes: http://nossosrobos.blogspot.com.br/2012/05/arduino-wireless-parte-ii-via-bluetooth.html

Conexão em rede ZigBee
• ZigBee designa um conjunto de especificações
para a comunicação sem-fio entre dispositivos
eletrônicos, com ênfase na baixa potência de
operação, na baixa taxa de transmissão de
dados e no baixo custo de implantação;
• Pode-se formar uma rede com vários módulos,
de maneira que a informação seja transmitida
de um ao seguinte (Mesh) para aumentar o
alcance total.

Módulo XBee – ZigBee
• Módulo Digi XBee ZB - Antena Wire - Low Power
• Frequência de Transm.: 2,4 GHz
• Potência de Transm.: 1,25 mW
• Alcance Máximo estimado: até 120m (+1 dBm)
• Topologias de rede: P-to-P, P-to-M, ZigBee/Mesh
• Sleep Mode < 1µA
• RF Data Rate 250 kbps
• Segurança: 128-bit AES
• (10) GPIO, (4) ADC e 3V3 CMOS UART

Módulo XBee – ZigBee
• XBee e XBee-PRO ZB
• Frequência de Transm.: 2,4 GHz
• Potência de transm.: 63 mW (+18 dBm) / Int'l
10 mW (+10 dBm)
• Alcance Máximo estimado: 3200 m
• RF Data Rate: RF 250 kbps, Serial até 1 Mbps
• Segurança: 128-bit AES
• Antena PCB - Ref: PIT

Ethernet Shield

Arduino com MATLAB
Detalhes: http://nossosrobos.blogspot.com.br/2011/10/arduino-com-matlab.html

Arduino com LabVIEW
Detalhes: http://sine.ni.com/nips/cds/view/p/lang/pt/nid/209835

http://www.blendedtechnologies.com/realtime-plot-of-arduino-serial-data-using-python/231
Aquisição de dados com Arduino

Aquisição de dados com Arduino

Controle de um Robô
Detalhes: http://nossosrobos.blogspot.com.br/2012/09/monte-seu-robo-com-arduino.html

Robôs baseados em Arduino
• DFRobotShop Rover - Arduino
Compatible Tracked Robot

Robôs baseados em Arduino
• DFRobotShop Rover 2.0 – Arduino
Compatible Mecanum

Robô Arduino oficial
• Arduino Robot
Detalhes: http://nossosrobos.blogspot.com.br/2013/07/arduino-robot-o-primeiro-robo-arduino.html

Softwares gratuitos
• IDE de programação do Arduino:
www.arduino.cc
• Fritzing - para fazer esquemas elétricos, de
proto-board e placas de circuito impresso:
www.fritzing.org
• 123D Circuits.io - para simulação de circuitos
com ou sem Arduino e projeto de placas de
circuito impresso (roda no navegador):
http://123d.circuits.io

Referências
• ARDUINO. Language Reference. Disponível em:
<http://arduino.cc/en/Reference/HomePage>. MAR/2014.
• ERIKSSON, Fredrik. Industrial Circuits Application Note - Stepper
Motor Basics.
• FONSECA, Érika e BEPPU, Mathyan. Apostila Arduino. CT/UFF, 2010.
• JUSTEN, Álvaro. Curso de Arduino (apostila), 2011.
• LIMA, Charles B. de; VILLAÇA, Marco V. M. AVR e Arduino – Técnicas
de Projeto. 2ª ed. 2012.
• MARTINS, Felipe N. Introdução à Eletrônica com Arduino. Disponível
em: <http://www.slideshare.net/felipenm/oficina-de-introduo-a-eletrnica-
com-arduino>.
• Nossos Robôs: www.nossosrobos.blogspot.com
• POMÍLIO, J.A. Eletrônica de Potência. UNICAMP (apostila para o
curso de graduação). Acesso em AGO/2010.
• http://www.labdegaragem.com.br/wiki
• http://www.learningaboutelectronics.com/
• VALPEREIRO, Filipe. Workshop Arduino, 2008.

Obrigado!
Felipe N. Martins
@f_n_martins
www.facebook.com/felipenm

Introdução a Sistemas Embarcados com Arduino - mini-curso

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (20)

Semelhante a Introdução a Sistemas Embarcados com Arduino - mini-curso

Semelhante a Introdução a Sistemas Embarcados com Arduino - mini-curso (20)

Mais de Felipe Martins

Mais de Felipe Martins (6)

Último

Último (20)

Introdução a Sistemas Embarcados com Arduino - mini-curso