Edição atual tal como às 14h50min de 14 de agosto de 2025

PLANO DE AULA

CARGA HORÁRIA: 5 h
CARGA HORÁRIA TEÓRICA: 2 h CARGA HORÁRIA PRÁTICA: 3 h

MATERIAIS

Por aluno:

1 placa Arduino Uno

cabo de comunicação/alimentação USB

1 computador PC com software Arduino IDE instalado

1 proto shield para montagens

1 display LCD shield

cabos fêmea-macho

METODOLOGIA

Exposição dialogada dos conteúdos disponíveis, em projetor multimídia.

Navegação assistida em outros sites e portais, de conteúdos relacionados.

Montagens práticas e desenvolvimento em computador de aplicativos.

Testes de verificação e validação.

Introdução aos Microcontroladores

Apresentação sobre Microcontroladores

Apostila sobre Microcontroladores

A plataforma Arduíno

(Extraído da apostila Curso de Arduíno, de Álvaro Justen e do curso Programação Básica em Arduíno, UFSC)

Arduino 1 é um projeto que engloba software e hardware e tem como objetivo fornecer uma plataforma fácil para prototipação de projetos interativos, utilizando um microcontrolador.

O projeto do Arduino teve início em 2005 na cidade de Ivrea, Itália.

O Arduino é composto por uma placa com microcontrolador Atmel AVR e um ambiente de programação baseado em Wiring e C++.

Tanto o hardware como o ambiente de programação do Arduino são livres, ou seja, qualquer pessoa pode modificá-los e reproduzi-los.

O Arduino também é conhecido como plataforma de computação física.

PLATAFORMAS DE COMPUTAÇÃO FÍSICA: são sistemas digitais ligados a sensores e atuadores, que permitem construir sistemas que percebam a realidade e respondem com ações físicas. O Arduíno é baseado em uma placa microcontrolada, com acessos de Entrada/Saída (I/O), que permite a criação de sistemas embarcados para aplicações industriais, comerciais, amadoras, profissionais, dos mais variados tipos.

Existem inúmeros modelos de Arduínos, como veremos na sequência, mas existem alguns mais populares, como o antigo Duemilanove (2009, em italiano) e o Uno, muito utilizado atualmente.

A principal diferença entre um Arduino e um computador convencional é que, além ter menor porte (tanto no tamanho quanto no poder de processamento), o Arduino utiliza dispositivos diferentes para entrada e saída em geral.

Por exemplo: em um PC utilizamos teclado e mouse como dispositivos de entrada e monitores e impressoras como dispositivos de saída; já em projetos com o Arduino os dispositivos de entrada e saída são circuitos elétricos/eletrônicos.

Como a interface do Arduino com outros dispositivos está mais perto do meio físico que a de um PC, podemos ler dados de sensores (temperatura, luz, pressão etc.) e controlar outros circuitos (lâmpadas, motores, eletrodomésticos etc.), dentre outras coisas que não conseguiríamos diretamente com um PC.

A grande diferença com relação ao uso desses dispositivos, no caso do Arduino, é que, na maior parte das vezes, nós mesmos construímos os circuitos que são utilizados, ou seja, não estamos limitados apenas a produtos existentes no mercado: o limite é dado por nosso conhecimento e criatividade! O melhor de tudo nesse projeto é que seu software, hardware e documentação so abertos. O software é livre (GNU GPL2), o hardware é totalmente aberto, especificado (basta entrar no site e baixar os esquemas) e a documentação está disponível em Creative Commons3, os usuários podem colaborar (seja escrevendo documentação, seja traduzindo) através da wiki!

Referências:

Modelos de Arduíno

Arduino UNO
Arduino Leonardo
Arduino Due
Arduino Esplora
Arduino Mega
Arduino Mega ADK
Arduino Ethernet
Arduino Mini
Arduino LilyPad
Arduino Micro
Arduino Nano
Arduino ProMini
Arduino Pro
Arduino Fio

Quadro Comparativo

(arduino.org)

Arduino UNO:

Talvez o modelo mais popular atualmente seja o Uno:

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: 16 MHz

Alimentação

O Arduino UNO pode ser alimentado pela porta USB ou por 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.

Mais informações: Hardware do UNO

Instalação do software

Para criar um projeto com o Arduino, basta comprar uma placa Arduino (utilizaremos o Arduino Uno, como exemplo) (que custa em torno de US$30 no exterior e por volta de R$100 no Brasil), fazer download da interface integrada de desenvolvimento (IDE) e ligar a placa à porta USB do PC.

Como qualquer computador/microcontrolador, o Arduino precisa de um software para executar comandos. Esse software será desenvolvido na Arduino IDE em nosso PC, utilizando a linguagem C/C++.

Após escrever o código, o compilaremos e então faremos o envio da versão compilada para a memória ‘’flash’’ do Arduino, através da porta USB.

A partir do momento que o software é gravado no Arduino não precisamos mais do PC: o Arduino conseguirá executar o software independentemente, modo ‘’standalone’’, desde que seja ligado a uma fonte de energia. Antes de iniciar nosso projeto precisamos então instalar a IDE.

O ambiente de desenvolvimento do Arduino (IDE) é gratuito e pode ser baixado no seguinte endereço: [Arduino.org/software#ide]

Vamos lá:

Ubuntu GNU/Linux 10.10: Basta executar em um terminal:

sudo aptitude install arduino

ou procurar pelo pacote \arduino no Synaptic (menu Sistema!Administração!Gerenciador de pacotes Synaptic).

Ubuntu GNU/Linux (anterior a 10.10): Consulte a página de instalação do Arduino em Ubuntu.
Outras distribuições GNU/Linux: Consulte a página de instalação em outras distribuições GNU/Linux.
Microsoft Windows: Basta baixar o arquivo de instalação e clicar duas vezes no mesmo. Consulte a página de instalação para as variadas versões do Microsoft Windows.
Apple Mac OS X: Consulte a página de instalação para o Mac OS X.

Após a instalação, abra a IDE. A seguinte tela será mostrada:

As seguintes configurações são necessárias:

Chamamos um código feito para Arduino de sketch e o salvamos em um arquivo com a extensão .pde.

Com nosso sketch pronto, bastará conectar o Arduino na porta USB e clicar no botão upload (segundo, da direita para a esquerda { destacado na figura acima).

Após o processo, será vista a mensagem Done uploading na IDE e então o sketch estará rodando no Arduino, ou seja, o LED acenderá e apagará, de 1 em 1 segundo. Vamos agora à explicação do processo:

IDE Arduino

Utiliza uma biblioteca de funções que simplifica a sua programação, por meio de uma sintaxe similar a das linguagens C e C++ (Wiring).

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 (menu Upload)
Permitir comunicação serial com o PC

Mais detalhes sobre a IDE: IDEArduino IDE Arduino Menus

Funções

As duas principais funções de um código Arduíno, isto é, de um programa desenvolvido para o Arduino são:

setup(): onde devem ser definidas algumas configurações iniciais do programa. Executa uma única vez, no início.
loop(): função principal do programa. Fica executando indefinidamente.

Todo programa para o Arduino deve ter estas duas funções!

Exemplo 1: acionando o led da placa (pino digital 13)

Começaremos com o exemplo clássico Blink, que já vem como exemplo, no aplicativo.

Para encontrar o exemplo clique em File ! Examples ! Digital ! Blink.

O programa tem como objetivo acender e apagar o LED de um em um segundo. Para compilar este exemplo não é necessário de nenhuma outra infraestrutura, ou hardware, que não o próprio Arduino.

Primeiramente, vamos criar uma variável chamada ledPin para endereçar o pino de saída, onde o LED da placa já está conectado (variável do tipo inteiro):

int ledPin = 13;

Assim quando nos referirmos à variável ledPin, estaremos nos referindo ao pino 13.

Este tipo de instrução não é obrigatória, mas é uma das boas práticas de programação e organização de código!

O seguinte passo é classificar o ledPin como pino de SAÍDA, porque os pinos são bidirecionais.

Isto é feito da seguinte maneira:

void setup() {
  pinMode(ledPin, OUTPUT);
 }

A função pinMode() tem como primeiro parâmetro o número do pino e como segundo parâmetro, se ele é pino de entrada ou saída.

Agora começaremos a escrever o processamento.

O programa rodará em um loop eterno, pois não deverá haver interrupções (ocorrências ou interferências que mudem o estado).

Dentro do loop terá uma função que fará o LED ficar aceso por 1 segundo e depois apagado, por mais um segundo, e assim, sucessivamente.

Escreva da seguinte maneira:

void loop() {
    digitalWrite(ledPin, HIGH);
    delay(1000);
    digitalWrite(ledPin, LOW);
    delay(1000);
 }

A função delay(x) pára a execução do código durante x milissegundos (ms). Por isto temos que utilizar o argumento 1000, para setar os atrasos em 1 segundo (=1000 ms).

O código completo poderia ser:

A função digitalWrite() escreve uma informação digital (nível lógico), ou seja, 0 (LOW) ou 1 (HIGH) em uma das saídas digitais. Seu primeiro parâmetro é o pino de saída, que no caso é o ledPin (pino 13). O segundo parâmetro é o estado a ser atribuído ao pino, HIGH ou LOW.

Quando uma porta digital está em estado baixo (LOW), ela estará em 0V; já quando está em estado alto (HIGH), estará com 5 V.

Antes de fazer o upload do programa (carregar o código pra memória FLASH do Arduíno), primeiro deve-se escolher a porta USB em que o Arduino se encontra (conectado ao PC).

Para isso vá em Tools ! Serial Port ! porta, para setar onde porta é o nome da porta onde estão ligados o Arduino (/dev/ttyUSB*, no caso de GNU/Linux, COM* em Windows).

Para saber em qual porta o Arduino se encontra, faça por tentativa e erro, logo escolha um e tente rodar, caso não rode, é o outro.

Outro passo que deve-se fazer é escolher o modelo da placa, para isso vá em: Tools ! Board e o modelo da sua placa.

Agora sim para fazer o upload, clique em Upload, como mostra a figura abaixo:

Deve-se ressaltar que a IDE Arduino inclui automaticamente todas as bibliotecas que utilizamos.

Se você está acostumado com C/C++, note que não precisamos digitar as diretivas include para arquivos como o stdlib.h, por exemplo.

Tudo é feito de forma automática para facilitar o desenvolvimento do projeto!

Como o Arduino já vem com um LED internamente conectado á porta 13, não precisaremos de circuitos externos para que esse projeto funcione, ou seja, bastará fazer upload daquele código e já teremos o resultado esperado:

Exercícios:

Altere o código para que o led da placa fique 2 segundos apagado e 3 segundos aceso.
Altere o código para que o led da placa fique 1 segundo aceso, 2 segundos apagado, mais meio segundo aceso e 300 ms apagado.
Porque a função delay() é necessária?
Porque foi necessário utilizar-se o pino digital 13?

Outras funções

Digital I/O

pinMode() 
digitalWrite() 
digitalRead()

Analógico I/O

analogReference() 
analogRead() 
analogWrite() - PWM

Avançado I/O

tone() 
noTone() 
shiftOut() 
pulseIn()

Tempo

 millis() 
 micros() 
 delay() 
 delayMicroseconds()

Matemática

min() 
max() 
abs() 
constrain() 
map() 
pow() ***só do C/C++ sqrt() ***só do C/C++

Trigonométrica

sin() ***só do C/C++ 
cos() ***só do C/C++ 
tan() ***só do C/C++

Números aleatórios

randomSeed() 
random()

bits e Bytes

lowByte() 
highByte() 
bitRead() 
bitWrite() 
bitSet() 
bitClear() 
bit()

Interrupções externas

attachInterrupt() 
detachInterrupt()

Interrupções

interrupts() 
noInterrupts()

Comunicação Serial

Serial.

begin()  
read()  
write()  
print()  
println() e 
available()

Acionando display LCD com arduino

A maioria das aplicações demanda o uso de um display LCD comum, que nada mais é do que uma matriz 16x2 de leds, para visualização dos resultados.

Nesta aula, veremos como escrever neste, usando o arduino.

O display LCD1602

O display de cristal líquido padrão LCD1602 tem este nome por ter 16 colunas e duas linhas.

Cada caractere é composto de uma matriz de 5 colunas por 8 linhas de pixels.

O estado desses pixels, “ligados” ou “desligados”, desenharão o caractere.

Veja a seguir como estão dispostos esses pixels em um caractere.

O estado dos pixels é definido através das entradas DB’s do módulo LCD.

O Arduino enviará 8 bytes através dessas portas para que seja definido o caractere.

Por exemplo, veja como é formada a letra V:

Felizmente, os usuários de arduino não precisam criar uma biblioteca de caracteres. Ela já existe e se chama LiquidCrystal.h.

A biblioteca já possui várias combinações para caracteres alfanuméricos, dessa forma não é necessário definir no programa cada caractere que será usado.

Porém, caso você queira criar um caractere personalizado, também será possível.

Pinagem do display

O display 1602 possui a seguinte pinagem:

Obviamente:

o pino Vss/1 do display tem que ser ligado ao GND do Arduino
o pino Vdd/2, ao VCC (+5V).
o pino V0/3 pode ser ligado a um potênciometro, para ajuste do contraste e
os pinos de anodo (A/15) e catodo (K/16) do display têm que ser ligados, respectivamente, ao VCC e ao GND, para acionar a backlight.

Os 8 pinos de dados (DB0/7 a DB7/14) vão ser ligados a saídas digitais do arduino.

Os demais pinos, RS/4, RW/5 e E/6 são de configuração.

A biblioteca LiquidCrystal.h

LiquidCrystal é o construtor que cria um objeto da classe LiquidCrystal.

Ou seja, define em quais pinos do Arduino o módulo está conectado.

Ele é sobrecarregado de 4 maneiras diferentes, onde tela, é o nome escolhido para o seu LCD.

LiquidCrystal tela(RS, Enable, DB4, DB5, DB6, DB7) 
LiquidCrystal tela(RS, RW, Enable, DB4, DB5, DB6, DB7) 
LiquidCrystal tela(RS, Enable, DB0, DB1, DB2, DB3, DB4, DB5, DB6, DB7) 
LiquidCrystal tela(RS, RW, Enable, DB0, DB1, DB2, DB3, DB4, DB5, DB6, DB7)

Caso o pino RW/5 não seja passado ao construtor, ele deve ser conectado ao GND para permitir a escrita no LCD.

Observe que não é necessário enviar todos os pinos de dados ao construtor, pois o Arduino consegue controlar o display utilizando apenas os 4 últimos pinos.

Observe que em nossos exemplos abaixo, usamos a primeira opção de construtor, com o nome lcd para o objeto.

Função begin()

 lcd.begin(colunas, linhas) ;

Inicializa a interface com o display, recebendo como parâmetros o número de colunas e linhas do display.

Deve ser chamada antes de qualquer outro método da classe.

Como nosso display possui 16 colunas e 2 linhas, temos:

 lcd.begin(16,2);

Função setCursor()

lcd.setCursor(coluna, linha) ;

Posiciona o cursor do display nas coordenadas passadas pelo parâmetro, para que o texto possa ser escrito na posição desejada.

lcd.setCursor(6,1);         //Posiciona o cursor na posição (6,1)

Função home()

lcd.home();

Posiciona o cursor no canto superior esquerdo do display. Equivale ao setCursor(0,0).

Função print()

lcd.print(conteúdo, base);

Escreve o conteúdo (char, int, string, byte ou long) na tela do display, na posição atual do cursor.

O parâmetro base é opcional e indica apenas a base em que os números serão impressos (BIN para binário, DEC para decimal, OCT para octal e HEX para hexadecimal).

Ao término da escrita, o cursor é movido para a próxima posição.

Função clear()

lcd.clear();

Limpa a tela do LCD e posiciona o cursor na extremidade superior esquerda.

Função write()

 lcd.write(caracter) ;

Escreve um caractere no LCD na posição atual do cursor, movendo o cursor para a próxima posição.

Função createChar()

lcd.createChar(número, caractere);

Cria um caractere customizado para ser utilizado no display, até, no máximo, 8 caracteres.

O símbolo criado é formado por um array de 8 bytes, onde os 5 bits menos significativos de cada byte determinam os pixels de cada linha.

O parâmetro número recebe um inteiro de 0 a 7, que simboliza qual caractere está sendo criado.

O parâmetro caractere recebe um vetor de 8 bytes que desenham o caractere, tal como apresentado no exemplo abaixo:

Com os caracteres smile e smile 2 definidos da seguinte forma:

E o restante do código:

lcd.createChar(0, smile);   //Cria o smile e o associa ao 0 
lcd.createChar(1, smile2);  //Cria o smile2 e o associa ao 1

Para o caractere 0 é necessário que, no momento de imprimi-lo, faça-se um casting do número do caractere criado para um byte.

lcd.write(byte(0));

O que não acontece com os demais.

lcd.write(1);

Maiores detalhes acerca da biblioteca LiquidCrystal.h]

Display LCD 16x2 com arduino

Programa Exemplo

Este exemplo utiliza o display LCD 1602 puro, sem shield (como o que utilizaremos abaixo). As ligações são as seguintes:

ARDUINO (pinos digitais 0-14)  ***********    DISPLAY (pinos 1-16)
-------------------------------------------------------------------
   2                                            4 (RS)
   3                                            6 (E)
   4                                            11 (DB4)
   5                                            12 (DB5)
   6                                            13 (DB6)
   7                                            14 (DB7)
  VCC (+5V)                                     15 (A) e 2 (VDD)
  GND (0V)                                      16 (K) e 1 (VSS)

Além do pino 3 do display, que está ligado no terminal central do potenciômetro, para ajuste do contraste.

Isso significa que a função construtora terá que ser:

 LiquidCrystal tela(2, 3, 4, 5, 6, 7) ;   //ligados, respect., a 4, 6, 11, 12, 13, 14 do display

Montagem:

Código:

#include <LiquidCrystal.h>     //inclui biblioteca no programa 
 
LiquidCrystal lcd(2,3,4,5,6,7);  /*Cria objeto lcd da classe LiquidCrystal 
RS     2 
Enable 3 
DB4    4 
DB5    5 
DB6    6 
DB7    7 */ 

//Cria um smile 
byte smile[8] = {B11111, B00000, B01010, B00000, B10001, B01110, B00000, B00100, };   

//Cria outro smile 
byte smile2[8] = {B00000, B00000, B01010, B01010, B00000, B10001, B11111, B00000, }; 

void setup(){   
  lcd.begin(16,2);            //Inicializa display de 2 linhas x 16 colunas   
  lcd.createChar(0, smile);   //Cria o smile e o associa ao 0   
  lcd.createChar(1, smile2);  //Cria o smile2 e o associa ao 1   
  lcd.home();                 //Posiciona cursor no canto superior esquerdo   
  lcd.print("3 ");            //Executa uma pequena contagem regressiva   
  delay(500);   
  lcd.print("2 ");   
  delay(500);   
  lcd.print("1 ");   
  delay(500);   
  lcd.clear();                //Limpa a tela do LCD   
  lcd.print("Microcontroladores");  //Escreve texto   
  lcd.setCursor(6,1);         //Posiciona o cursor na posição (6,1)   
  lcd.write(byte(0));         //Escreve o smile   
  lcd.setCursor(8,1);         //Posiciona o cursor na posição (8,1)   
  lcd.write(1);               //Escreve smile2 
}   

void loop()
{   }

Displays LCD Keypad Shield

Como foi visto, acionar displays LCD pode ser uma tarefa chata e nada trivial, mesmo com a biblioteca LiquidCrystal.h.

Felizmente, o curso de Engenharia Elétrica do IFSC, Campus Itajaí dispõe de shields com displays LCD 16x2, ou Keypad Shields, os quais prescindem de todo cabeamento e protoboards externos.

O funcionamento deste pode ser compreendido nos links:

Funcionamento do Keypad Shield

Escrever texto deslizante ("scrolling text") no display:

#include <LiquidCrystal.h>  
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);  
void setup()   
{ lcd.begin(16, 2);  
  lcd.setCursor(0,0);  
  lcd.print("Fernanda - MIC2");
  delay(2000);
}  
  
void loop()  
{ int i;
  for(i=0;i<16;i++)
  { lcd.setCursor(i,1);  
    lcd.print("Texto deslizante");  
    delay(300);
    lcd.clear();
 }
}

Texto deslizante usando a função scrollDisplayLeft:

#include <LiquidCrystal.h> 
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);  

void setup()   
{ lcd.begin(16, 2);   
  lcd.setCursor(15,0); 
  lcd.print("Fernanda - MIC2");
}  
  
void loop()  
{  
  lcd.scrollDisplayLeft();   
  delay(500); 
}

media: lcdVIDEO.mov video

Identificar tecla pressionada e mostrar no display

#include <LiquidCrystal.h>  
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);  
  
void setup()   
{  
 lcd.begin(16, 2);  
 lcd.setCursor(0,0);  
 lcd.print("Fernanda - MIC2");
 lcd.setCursor(0,1);  
 lcd.print("Tecla:");  
}  
  
void loop()  
{  
 int botao;  
 botao = analogRead (0);  //Leitura do valor da porta analógica A0
 lcd.setCursor(10,1);  
 if (botao < 99) {  
  lcd.print ("Direita ");  
 }  
 else if (botao < 200) {  
    lcd.print ("Cima    ");  
 }  
 else if (botao < 400){  
    lcd.print ("Baixo   ");  
 }  
 else if (botao < 600){  
   lcd.print ("Esquerda");  
 }  
 else if (botao < 800){  
   lcd.print ("Select  ");  
 }  
}

Programa-exemplo de uso do Keypad Shield

<< Página do curso	AULA 1 - Introdução aos Microcontroladores	Arquitetura do Arduíno >>

AULA 1 - Microcontroladores - Engenharia: mudanças entre as edições