EBOOK-ARDUINO-BASICO

Prévia do material em texto

TREINAMENTO BÁSICO ARDUINO 
 
O que é o Arduino? 
Talvez você que esteja lendo esse livro não tenha conhecido alguns processadores e 
a sua dificuldade em escrever um código, gravar neles um programa, até mesmo 
bibliotecas que ensinasse como usá-los e configurar. O que tinha era de uma linguagem 
difícil de entender para os novatos na área da programação de embarcados ou era em 
inglês, para passar o código, tinha todo um “ritual” em gravar o chip espetado em uma 
placa específica para gravação e depois precisamos removê-los para testar em nosso 
protótipo. Tudo isso que relatei foi substituído pelo Arduino, ele é uma plataforma 
eletrônica de código aberto baseado em hardware e software livres, de fácil uso e 
grande material disponível na internet e em livros, inclusive esse que você está lendo. 
Tudo isso graças a uma grande comunidade mundial de criadores - estudantes, 
entusiastas, programadores e profissionais que se reúne todos os dias em torno desta 
plataforma de código aberto. Suas contribuições adicionam uma quantidade incrível de 
conhecimento acessível que pode ser de grande ajuda para iniciantes e especialistas. 
As placas do Arduino são capazes de ler o ambiente como a luz através de um sensor, 
um dedo em um botão ou até mesmo uma mensagem no Twitter, de posse dessas 
entradas, nossa super placa pode transformá-las em uma saída como por exemplo, 
ativando um motor, ligando um LED, publicando algo online. esse tratamento da 
entrada para a saída quem decide é você, dizendo para a sua placa o que deve fazer 
através de um conjunto de instruções pré-programadas no microcontrolador da placa. 
Para fazer isso, você usa a linguagem de programação Arduino, com base na Wiring, 
e o Software Arduino (IDE) , com base no Processing, no próximo capítulo falaremos 
um pouco desses dois softwares. 
Já a algum tempo o Arduino vém sendo o cérebro de milhares de projetos makers, 
engenheiros, estudantes e entusiastas, também já é parte de vários objetos do nosso 
dia a dia até a complexos instrumentos científicos, por esse motivo escrevemos esse 
livro, para divulgar essa ferramenta maravilhosa e suas variedades. 
Por falar em variedades, atualmente o Arduino tem mais de 40 modelos de placas, 
desde as mais simples e tradicionais como o Arduino Uno (será a que adotaremos neste 
livro) até as mais avançadas com capacidade de processamento de programas com 
inteligência Artificial e Internet das Coisas, então vamos comigo conferir no próximo 
capítulos os principais tipos de Arduino. 
Tipos de Arduino 
Arduino UNO 
http://forum.arduino.cc/
https://www.arduino.cc/en/Main/Products
https://www.arduino.cc/en/Reference/HomePage
https://www.arduino.cc/en/Main/Software
 
 
O Arduino Uno é uma placa microcontrolada baseada no ATmega328P. Ela 
possui 14 pinos de entrada / saída digitais (dos quais 6 podem ser usados como 
saídas PWM), também possui 6 entradas analógicas, um cristal de quartzo de 
16MHz, uma conexão USB, um conector de alimentação até 16V, um bloco de 
pinos ICSP e um botão de reset. 
 
 O nome UNO em Italiano significa “um” e foi escolhido para referenciar a versão 
primeira versão no lançamento do Arduino Software IDE 1.0, a placa UNO foi a 
primeira de uma série de placas USB Arduino que surgiram até a data de hoje. 
 Na imagem abaixo tem detalhadamente a descrição da pinagem do Arduino 
UNO. 
 
O Arduino Uno pode ser programado com o Software (IDE) do seu Arduino, basta 
selecionar "Arduino / Genuíno Uno” no menu Ferramentas> Placa (de acordo com o 
microcontrolador em sua placa). O ATmega328 no Arduino Uno já vem pré-programado 
com um gerenciador de inicialização que permite carregar um novo código nele sem o 
uso de um programador de hardware externo. Ele se comunica usando o protocolo 
STK500 original que consiste em uma série de comandos e respostas, todas elas em 
ASCII padrão, para troca de dados e execução de tarefas, esse protocolo serve para 
que o Arduino IDE e o Bootloader se entendam e façam o upload corretamente do seu 
sketch. 
Caso você gere um curto-circuito em seu Arduino Uno, isso poderia queimar a porta 
USB de meu computador? A resposta é não, pois o Arduino Uno possui um fusível 
reinicializava que protege as portas USB do seu computador contra curtos-circuitos e 
sobrecorrentes, embora seu computador já forneça um circuito de proteção interna nas 
suas portas USB, o fusível do Arduino Uno irá fornecer uma camada extra de proteção, 
caso ocorra uma corrente maior que 500 mA o fusível interromperá automaticamente a 
conexão até que o curto ou sobrecarga seja removido. 
E aí? Gostou de conhecer o Arduino UNO? Pois estamos apenas começando nosso a 
aventura em nosso livro, se os benefícios da primeira placa já lhe encantaram, continue 
lendo para você conhecer as outras placas e suas diferenças, vamos lá? Então vamos 
falar agora da prima do Uno, vamos conhecer o Arduino Leonardo. 
 
Arduino Leonardo 
 O Arduino Leonardo é parecido com o Arduino Uno, porém tem um diferencial 
especial, ele pode ser usado com mouse e teclado, ficou curioso? Pois fique um 
pouco mais nesse capítulo para aprender sobre o Arduino Leonardo. 
 
 
Outra diferença do Arduino Leonardo para o Uno é que o microcontrolador é o 
ATmega32u4. Os dois microcontroladores, o ATMega328P e o ATMega32U4 estão na 
família AVR e têm 32K de memória flash (daí os 32 no nome). O que difere é no pacote 
e quais periféricos são oferecidos. A maior diferença é que o 32U4 possui um periférico 
de dispositivo USB (daí o U no nome), o 328P não possui um periférico USB dedicado, 
o Arduino Uno necessita de outro ATmega para essa conexão USB acontecer. O “P” é 
referente ao PicoPower, que é um conjunto de recursos que permitem economizar 
energia, incluindo desligar periféricos que não estão em uso. Possui 20 pinos de 
entrada / saída digitais, porém, diferenciando do Arduino Uno, das 20 portas E/S 7 
podem ser usados como saídas PWM e 12 como entradas analógicas, ou seja, tenho 
mais opções de usar o recurso PWM e ADC. Possui um oscilador de cristal de 16MHz 
e uma conexão micro USB, aquela igual dos celulares smartphone, diferente do Arduino 
Uno que a conexão USB é tipo A-B igual a usada em impressoras. Também possui um 
conector tipo Jack de energia, um cabeçalho ICSP e um botão de reset. 
Como mencionado anteriormente, a placa Leonardo tem um diferencial exclusivo das 
demais placas, o ATmega32u4 possui comunicação USB integrada, eliminando a 
necessidade de um processador secundário. Isso permite que o Leonardo apareça em 
um computador conectado como mouse e teclado, além de uma porta serial / COM 
virtual (CDC). 
 
A pinagem do Leonardo é bem parecida com a do Uno, porém tem algumas diferenças, 
abaixo apresento o diagrama PinOut do Arduino Leonardo, vale a pena sentar-se e 
pesquisar um pouco sobre essas diferenças, neste livro não temos o intuito de se 
aprofundar no Hardware da placa, apenas apresentá-la e caminhar para o nosso 
objetivo que é fazer projetos. 
 
No site www.arduino.cc, clicando na aba “Resources>Products” você encontrará todas 
as informações necessárias sobre o Arduino Leonardo e outras placas. 
 
Arduino Mega 2560 
 O Arduino MEGA 2560 foi desenvolvido para projetos mais complexos que 
necessitam de muitas portas de entrada e saída, ele é ideal para esses projetos pois 
conta com 54 pinos de E / S digitais e 16 entradas analógicas, é a placa recomendada 
para impressoras 3D e projetos de automação residencial e veicular. Ele é uma placa 
de microcontrolador baseada no ATmega2560, entre as portas de entrada e saída 15 
http://www.arduino.cc/
delas podem ser usados como saídas PWM, possui também 4 UARTs (portas seriais 
de hardware), um oscilador de cristal de 16 MHz, uma conexão USB, um conector JACK 
de alimentação, um cabeçalho ICSP, e um botão de reset. 
 
 
O Mega 2560 também possui um polyfuse reinicializava que protege as portas USB do 
seu computador contra curtos-circuitos esobrecorrentes. Se mais de 500 mA for 
aplicado à porta USB, o fusível interrompe automaticamente a conexão até que o curto 
ou sobrecarga seja removido. 
Na imagem abaixo detalhamos as portas do Arduino Mega e caso queira se aprofundar 
mais, acesse o site www.arduino.cc, clicando na aba “Resources>Products”, você 
encontrará todas as informações necessárias sobre o Arduino Mega e outras placas. 
http://www.arduino.cc/
 
Arduino Nano 
O Arduino Nano hoje é um sucesso, chegando a se comparar ao imortal Arduino UNO, 
o Arduino Nano tem seu hardware bem parecido com o UNO, duas grandes diferenças 
são o tamanho compacto, o tipo de porta USB, usa a USB Mini - B para transferência 
do código e não possui um conector para alimentação DC da placa, essa alimentação 
precisa ser feita através dos pinos dispostos. Hoje o Nano tem várias versões, uma 
delas que está sendo sucesso é o Arduino Nano 33 IoT, não iremos nos aprofundar 
nessa placa neste livro, mas em nossa plataforma on-line iremos fazer vários projetos 
usando essa placa. 
 
Ela é baseada também no ATMega 328P, uma dica ao passar o código para a placa é 
que caso a IDE não a reconheça e gere o erro ao carregar o código, selecione a placa 
Arduino “Dueminalove” que possivelmente será transferido a programação com 
sucesso. Em relação ao Hardware ela tem seus pinos dispostos conforme figura abaixo: 
 
Instalação do software 
Para programar seu Arduino podemos usar de três meios, usando a IDE (Ambiente de 
Desenvolvimento Integrado) Web Editor, optando por esse recurso você codifica on-
line salvando seus esboços na nuvem ou enviar para qualquer placa oficial do Arduino 
a partir do seu navegador (Chrome, Firefox, Safari e Edge) e sempre tendo a versão 
mais atualizada do IDE incluindo todas as bibliotecas contribuídas e suporte para novas 
placas Arduino. Arduino Web Editor reconhece automaticamente qualquer placa 
Arduino Genuina que for conectada ao seu PC, basta você criar uma conta do Arduino 
que iremos lhe mostrar o passo a passo de como fazer seguindo o tutorial do site 
www.arduino.cc. 
 
Arduino Web Editor 
Passo 01: Inscreva-se no Arduino 
Crie uma nova conta Arduino, preencha o formulário de inscrição e clique no botão ' 
Create Account'. Você receberá um email com um link para ativar sua conta. 
Selecione o link e uma nova página será aberta com as informações da sua conta 
confirmada. 
http://www.arduino.cc/
https://auth.arduino.cc/register
 
Passo 02: Faça login no Arduino Web Editor 
Depois de se registrar com sucesso em uma conta do Arduino, acesse 
create.arduino.cc/editor, aceite o termo e as condições, logo mais você deverá 
receber um email com um link para o Fórum, onde poderá relatar quaisquer bugs 
que encontrar e compartilhar seus comentários. O Arduino Web Editor pode ser 
executado em várias plataformas. Se você estiver usando Windows, Mac ou 
Linux, siga um fluxo simples para instalar o plug-in do Arduino Web Editor , que 
permite fazer upload de esboços do navegador para as placas, ao terminar a 
instalação você será direcionado para a página de login do Arduino. 
 
Após o login, você está pronto para começar a usar o Arduino Web Editor. O 
aplicativo da web é dividido em três colunas principais como pode ver na imagem 
abaixo: 
https://create.arduino.cc/editor
http://forum.arduino.cc/index.php?board=101.0
https://github.com/arduino/arduino-create-agent
https://github.com/arduino/arduino-create-agent
 
A primeira coluna permite navegar entre: 
● Seu Sketchbook : uma coleção de todos os seus esboços (' sketch ' é como 
os programas que você carrega no seu quadro são chamados). 
● Exemplos: esboços somente leitura que demonstram todos os comandos 
básicos do Arduino (guia interna) e o comportamento de suas bibliotecas (na 
guia bibliotecas) 
● Bibliotecas: pacotes que podem ser incluídos no seu esboço para fornecer 
funcionalidades extras 
● Monitor serial: um recurso que permite receber e enviar dados para sua placa 
via cabo USB 
● Ajuda: links úteis e um glossário sobre os termos do Arduino 
● Preferências: opções para personalizar a aparência e o comportamento do seu 
editor, como tamanho do texto e tema da cor 
Quando selecionado, todos os itens de menu mostram suas opções em um painel 
lateral (segunda coluna ). 
A terceira coluna, a área de código, é a que você mais usará. Aqui, você pode escrever 
um código, verificá-lo e enviá-lo para seus painéis, salvar seus esboços na nuvem e 
compartilhá-los com quem quiser. 
Não optando por usar a IDE on-line o software te oferece a possibilidade de fazer o 
download do programa para uso off-line direto no seu computador. 
 
Download da IDE Arduino 
O seu Software pode ser instalado para uso nos sistemas operacional Windows, Linux 
e Mac, como o S.O. mais comum no Brasil é o Windows, será esse que irei detalhar na 
instalação seguindo o tutorial também disponível no site www.arduino.cc . 
 
Faça o Download do Software Arduino IDE 
Obtenha a versão mais recente na página de download escolhendo o pacote Installer 
(.exe), pois será instalado diretamente tudo o que você precisa para usar o Arduino 
Software (IDE), incluindo os drivers. . 
Quando o download terminar, continue com a instalação e permita o processo de 
instalação do driver quando você receber um aviso do sistema operacional. 
 
Escolha os componentes a serem instalados. 
http://www.arduino.cc/
https://www.arduino.cc/en/Main/Software
 
Na hora que pedir para escolher o diretório de instalação mantenha o padrão. 
 
O processo extrairá e instalará todos os arquivos necessários, após isso é só ir à área 
de trabalho e executar corretamente o Arduino através do atalho do ícone lá disposto. 
 
A nova IDE Arduino Pro Alpha 
Além dessas duas opções, no dia 19 de outubro de 2019, Massimo Banzi e Luca 
Cipriani lançaram ao vivo na Maker Faire Rome a nova IDE, categorizada como “Versão 
Alpha”, Arduino Pró IDE Alpha. 
 
Onde segundo o site oficial do Arduino, www.arduino.cc e o anúncio no evento ao qual 
estive presente, os principais recursos dessa nova versão são: 
● Ambiente de desenvolvimento moderno e completo 
● Modo Dual, Modo Clássico (idêntico ao IDE clássico do Arduino) e Modo Pro 
(visualização Sistema de Arquivos) 
● Novo gerenciador de placas 
● Novo Gerenciador de Bibliotecas 
● Lista de placas 
● Preenchimento automático básico 
● Integração com o Git 
● Monitor Serial 
● Modo escuro 
E tem mais, a equipe Arduino promete mais mudanças, novos recursos serão lançados 
em breve como: 
● Sincronização de esboço com o Arduino Create Editor 
● Depurador 
● Totalmente aberto para plug-ins de terceiros 
● Suporte para linguagens adicionais que não sejam C ++ 
Este livro não tem o intuito de lhe ensinar a usar a IDE Arduino Pró Alpha, até porque 
ainda está em processo de otimização, quem sabe no nosso livro volume 2 detalhamos 
e ensinamos seu uso, até lá, vamos usar a IDE tradicional offline que você baixou em 
seu computador. 
 
http://www.arduino.cc/
 
Capítulo 02 – Linguagem de Programação com a IDE Arduíno 
Antes de falarmos sobre linguagem de programação, gostaria de apresentar o 
conceito de Lógica de Programação onde é simplesmente a técnica de desenvolver 
sequências lógicas para atingir determinado objetivo seguindo uma regra lógica 
matemática, temporal ou outras regras básicas da Ciência da Computação. Após essa 
lógica formatada podemos transformá-las em uma linguagem de programação onde 
agora temos como princípio a sintaxe específica para cada tipo de linguagem. 
Ficou difícil de entender? Então deixa eu exemplificar, para atravessar uma rua, 
como você procede? Bem, eu caminho até a borda da calçada, paro, constato se estou 
de frente a uma faixa de pedestre, se estiver, olho para um lado e para o outro, se não 
vier carro eu inicio a travessia. Caso venha carro eu aguardo um tempo e depois repito 
a ação de olhar para os dois lados para decidir se atravessoou continuo aguardando 
não ter mais fluxo de carro, e se eu não estiver de frente a uma faixa de pedestre? Bem, 
nesse caso eu não posso atravessar, logo devo girar em 90° e caminhar até encontrar 
uma faixa para executar as ações descritas anteriormente e realizar meu objetivo, ou 
seja, a travessia. 
Ou seja, eu desenvolvi uma sequência lógica para atingir meu objetivo que seria 
atravessar a rua, porém o computador não entende essa minha lógica, logo preciso 
transformá-la em uma linguagem que ele intérprete e decodifique e essa linguagem é 
a que chamamos de linguagem de programação. 
O Arduino possui uma IDE própria, porém, uma IDE não é uma linguagem de 
programação, que deriva do inglês onde IDE significa Integreted Develpment 
Environment, ou seja, ambiente de Desenvolvimento Integrado, logo a IDE do nosso 
Arduino é uma ferramenta, que ajuda todo processo de desenvolvimento de software 
integrando outras ferramentas e facilitando seu uso. A sua principal função é ser um 
editor de texto. Logo, hoje em dia é muito comum a pessoas que estão iniciando 
confundir o Arduino como uma linguagem de programação, no entanto nossa IDE 
Arduino é uma aplicação multiplataforma escrita em Java derivada dos projetos 
Processing e Wiring, vamos conhecer cada uma delas? 
Processing 
Processing é uma linguagem de programação de código aberto desenvolvido 
para ensinar a comunidade de programação com uma metodologia visual e fácil 
de entender, foi projetado em 2001 para um público de não programadores tendo 
por base as capacidades básicas da linguagem de programação Java. 
https://processing.org/ 
Wiring 
A linguagem de programação Wiring é uma estrutura de programação de código 
aberto e voltada para o uso embarcado em microcontroladores permitindo a 
criação de software para controlar dispositivos conectados a uma ampla 
variedade de placas de microcontroladores como por exemplo o Arduino. A 
https://processing.org/
linguagem Wiring serve como base para a IDE Arduino ter essa versão 
simplificada da linguagem C++ que conhecemos. 
http://wiring.org.co/ 
 
Java 
Java é uma linguagem de programação orientada a objetos desenvolvida na 
década de 90 com algumas particularidades como a Portabilidade, ou seja, 
independência de plataformas, além de possuir uma extensa biblioteca de 
rotinas que facilitam a cooperação com protocolos TCP/IP. 
https://www.java.com/pt_BR/ 
Agora com todos os envolvidos devidamente apresentados, vamos programar 
então, acredito que você já passou pelo capítulo 01 e instalou seu software de 
acordo com seu sistema operacional, então abra a sua IDE Arduino e dedos nos 
teclados. 
 
Programando com Arduino 
 Caros leitores, agora com o entendimento do que é uma lógica de programação 
e tendo sido apresentado a algumas linguagens de programação chegou o momento 
de aprofundarmos na IDE que é objetivo de estudo neste livro, vamos estudar as 
estruturas, as funções, as bibliotecas, classes e métodos usados na IDE Arduino que 
você também já foi apresentado no capítulo anterior. 
● Estrutura inicial do seu programa 
O seu programa dentro da IDE Arduino se estrutura em 4 áreas onde você 
poderá programar, olhando para a imagem abaixo observe as áreas A, B, C e D, 
que iremos a seguir explicar um pouco sobre elas. 
http://wiring.org.co/
https://www.java.com/pt_BR/
 
A área “A” é onde você declara as variáveis global do seu programa (não se 
preocupe, iremos explicar o que é uma variável global e local e suas diferenças), 
nesse ambiente também incluímos as bibliotecas necessárias para o 
funcionamento de seu projeto, orientamos o objeto a classe da biblioteca e 
inicializamos alguns parâmetros necessários (tudo vai depender de seu projeto 
e objetivo). 
Então falamos aqui de declaração de variável, biblioteca, objeto e parâmetros, 
tudo isso pode parecer outro mundo para você mas não se preocupe que iremos 
estudar juntos e viajar para esse mundo do Arduino sabendo de tudo. 
o setup() 
A área “B” é o setup() de seu programa, é onde escrevemos as linhas 
de programação referente a configuração de seu código, é uma das 
funções que devem ser incluídas em todo o programa Arduino, ela é 
executada apenas uma vez em três situações, no momento em que a 
placa é ligada, resetada ou inicializado uma comunicação serial. Isso é 
útil para configurações que você só faz uma vez, como configurar a 
direção dos pinos definindo qual o modo de uso (INPUT ou OUTPUT), 
inicializar interfaces de comunicação e assim por diante. 
void setup() { 
 // coloque seu código de configuração aqui, 
 //para executar uma vez: 
} 
o loop() 
A área “C” é o loop() do seu programa, é a segunda função obrigatória 
em todos os programas Arduino. Nessa função, colocamos o núcleo de 
nosso código-fonte, o que estiver entre as chaves ( { } ) do loop será 
executado indefinidamente enquanto a placa estiver ligada, ou seja, seu 
comportamento padrão será de um ciclo de repetição, por isso é chamado 
de loop, logo o sketch será lido a partir da primeira linha após a chave até 
a última linha antes da chave de fechamento onde volta para o início do 
loop, ou seja para a primeira linha após a chave aberta no loop e percorre 
todas as linhas seguintes novamente se repetindo sucessivamente até 
que a placa seja desligada ou o botão de reset pressionado. Se quiser 
que o Arduino faça algo somente uma vez na inicialização (ou seja dentro 
do setup) você ainda precisa incluir a função loop, mas pode deixá-la 
vazia. 
void loop() { 
 // coloque seu código principal aqui, 
 //para executar repetidamente: 
} 
o Criando novo Void 
A área “D” do seu programa, é onde você pode criar uma nova função 
fora do ciclo de repetição loop, onde o seu programa só irá percorrer 
aquelas linhas quando for convidado a entrar nessa nova função. 
Por exemplo, dentro do void loop() posso ter uma condição onde se a 
pessoa pressionar um botão ela ligue um led, esse é um exemplo bem 
simples e não aplicável, mas retrata o funcionamento da chamada de 
função, então o programa ficaria assim: 
void loop() { 
 if (botao==0){ 
 ligaLED(); 
 } 
} 
void ligaLED(){ 
 digitalWrite(3,HIGH); 
} 
Mais uma vez, não precisa se preocupar agora com esse comandos 
novos, iremos ensiná-los no momento certo no decorrer deste livro. 
A nova função que acabamos de criar, ligaLED, é executada através de 
um void que está fora do loop e é chamada através do comando 
ligaLED(), ou seja, agora toda vez que eu precisar ligar um led dentro do 
meu programa eu não precisarei mais escrever digitalWrite(3, HIGH) (que 
é o comando para ligar o LED), apenas chamarei o comando ligaLED. 
Como disse essa não é ma aplicação ideal, criamos uma função nova 
quando teremos dentro dela uma sequência de instruções complexas que 
eu iria usar algumas vezes dentro do loop, para eu não ficar repetindo-as 
toda vez que precisar, gerando assim mais linhas de códigos e memória 
necessária para execução, com esse método o programa só executará 
quando for chamado realmente. 
 
● Imprimindo na Tela 
A impressão na tela é feito através da porta Serial, aprendemos no capítulo que 
fala sobre a placa Arduino que ele tem uma conexão USB, utilizada pela IDE 
para fazer o upload do código para o processador e essa mesma conexão pode 
ser utilizada pelos skecthes que desenvolvemos no Arduino para enviar dados 
ao computador ou ler dados do computador, para eu imprimir algo na tela 
primeiro preciso conhecer o botão SerialMonitor, é uma ferramenta muito útil, em 
especial para depurar o seu código, pois nele é exibido os dados seriais 
enviados do seu Arduino (USB ou placa Serial) e também poderá ser feito o 
inverso, enviar os dados de volta ao Arduino digitando algo na caixa de texto que 
é aberta assim que você clicar no botão Serial Monitor, observe a figura abaixo: 
 
Importante informar que essa tela só será aberta caso o Arduino esteja 
conectado a porta USBdo computador e com a porta serial selecionada, que irá 
aparecer na sua IDE comumente como COM3 ou COM4, iremos aprender a 
selecioná-la também quando formos escrever nosso primeiro código nesse 
capítulo ainda. 
O último ponto importante a se conhecer para estabelecermos uma comunicação 
Serial entre o Arduino e o computador de uma forma eficaz é definir a taxa de 
transmissão (Baud Rate) na qual os dados devem ser enviados de/para o 
Arduino. Essa taxa de transmissão é a taxa por segundos em que as alterações 
de estado ou dados, que são os bits, são enviadas da placa Arduino para o 
computador ou ao contrário, do Arduino para o computador. A configuração 
padrão é de 9600 baud, porém pode ser alterado no canto inferior direito do seu 
monitor serial conforme figura anterior. 
Conhecendo a forma de conectar e configurar a sua comunicação serial vamos 
entender então como imprimimos uma frase vinda do Arduino na tela do meu 
computador, para executar essa tarefa eu preciso que um objeto chamado Serial 
esteja instalado na minha IDE, para nossa sorte, assim que instalar a IDE 
Arduino a biblioteca SoftwareSerial ser´´a também instalada e a classe Serial é 
quem será responsável pela comunicação, ela traz consigo alguns métodos que 
são funções específicas para a ações específicas dentro meu programa: 
if(Serial), available(), availableForWrite(), begin(), end(), find(), findUntil(), flush(), 
parseFloat(), parseInt(), peek(), print(), println(), read(), readBytes(), 
readBytesUntil(), readString(), readStringUntil(), setTimeout(), write() e 
serialEvent(). 
 
Muitas linguagens de programação têm essa função que permite a criação de 
programas capazes de se comunicar com a porta serial, a Processing, que 
comentamos no início deste livro, é um exemplo de uma linguagem que usa 
desse recurso e um excelente complemento para projetos com seu Arduino por 
ter a opção de gerar gráficos de acordo com informações recebidas de sua placa. 
Durante a nossa jornada aqui neste livro iremos conhecer algumas dessas 
funções, porém neste capítulo iremos aprender 3 delas, vamos conhecê-las? 
 
o Função Serial.begin() 
Essa função abre a porta serial para enviar dados de volta ao computador 
a uma certa velocidade de transmissão que é definida pelo programador, 
de acordo com a necessidade da comunicação, e configurada 
posteriormente com a IDE. Conforme já comentado anteriormente a taxa 
de transmissão padrão é de 9600 bits por segundo. Taxa de transmissão 
(baud rate) mais rápidas permitem que você transmita mais dados em 
menos tempo, mas também podem gerar erros de transmissão em alguns 
sistemas de comunicação, então cuidado com experiências aleatórias 
usando taxas diferentes, seu projeto pode não se comportar como o 
esperado. 
Um segundo argumento opcional configura os dados, paridade e bits de 
parada. O padrão é 8 bits de dados, sem paridade, um bit de parada, 
observe a sintaxe dessa função: 
 Serial.begin(velocidade) 
 Serial.begin(velocidade, configuração) 
Serial: objeto de porta serial. 
velocidade: em bits por segundo (baud). Tipos de dados permitidos: long. 
configuração: define dados, paridade e bits de parada. Os valores válidos 
são vários, 24 no total, aqui neste livro mostrarei os três principais, que 
são: SERIAL_8N1 (esse é o padrão da IDE), SERIAL_5E1 (paridade par) 
e SERIAL_5O1 (paridade ímpar); caso queira conhecer todas as 
configurações válidas acesse o site do Arduino oficial, 
arduino.cc/reference/en/language/functions/communication/serial/begin/. 
Exemplo de um código: 
 void setup() { 
 Serial.begin(9600); 
} 
void loop() {} 
Além da porta USB também, o Arduino possui dois pinos são reservados 
para comunicação serial, conforme visto anteriormente neste livro, os 
https://www.arduino.cc/reference/en/language/functions/communication/serial/ifserial
https://www.arduino.cc/reference/en/language/functions/communication/serial/available
https://www.arduino.cc/reference/en/language/functions/communication/serial/availableforwrite
https://www.arduino.cc/reference/en/language/functions/communication/serial/begin
https://www.arduino.cc/reference/en/language/functions/communication/serial/end
https://www.arduino.cc/reference/en/language/functions/communication/serial/find
https://www.arduino.cc/reference/en/language/functions/communication/serial/finduntil
https://www.arduino.cc/reference/en/language/functions/communication/serial/flush
https://www.arduino.cc/reference/en/language/functions/communication/serial/parsefloat
https://www.arduino.cc/reference/en/language/functions/communication/serial/parseint
https://www.arduino.cc/reference/en/language/functions/communication/serial/peek
https://www.arduino.cc/reference/en/language/functions/communication/serial/print
https://www.arduino.cc/reference/en/language/functions/communication/serial/println
https://www.arduino.cc/reference/en/language/functions/communication/serial/read
https://www.arduino.cc/reference/en/language/functions/communication/serial/readbytes
https://www.arduino.cc/reference/en/language/functions/communication/serial/readbytesuntil
https://www.arduino.cc/reference/en/language/functions/communication/serial/readstring
https://www.arduino.cc/reference/en/language/functions/communication/serial/readstringuntil
https://www.arduino.cc/reference/en/language/functions/communication/serial/settimeout
https://www.arduino.cc/reference/en/language/functions/communication/serial/write
https://www.arduino.cc/reference/en/language/functions/communication/serial/serialevent
pinos 0 e 1 do Arduino servem para comunicar placas entre si, por 
exemplo, usando a comunicação serial, o Arduino Mega possui quatro 
pares de pinos serial e podem ser configurados com taxa de transmissão 
distintas, olhe o exemplo abaixo: 
 void setup() { 
 Serial.begin(9600); 
 Serial1.begin(38400); 
 Serial2.begin(19200); 
 Serial3.begin(4800); 
} 
void loop() {} 
 
Agora que já inicializamos a comunicação serial vamos enviar uma 
mensagem para a tela do computador, usando Serial.print(). 
 
o Função Serial.print() 
O uso do comando Serial.print irá enviar os dados para o seu computador 
como texto ASCII, que é a forma legível para os humanos, na tabela 
abaixo temos quatro colunas, a “Caracter” (é a forma de texto que 
entendemos), “Dec”, “Oct” e “Hex”. 
 
Quando escrevemos algo dentro dos parênteses do Serial.print entre 
aspas “ “, isso diz para o meu Arduino que a informação a ser enviada é 
uma string, ou seja uma palavra, e será impresso no monitor serial 
exatamente a informação entre os parênteses, por exemplo: 
 void setup() { 
 Serial.begin(9600); // inicia a comunicação serial 
} 
void loop() { 
 Serial.print("Livro sobre Arduino..."); 
 } 
 
Escreva esse código em sua IDE, conecte o Arduino e transfira o sketche 
para sua placa, observe o passo a passo abaixo: 
Passo 1: Programa escrito 
 
Passo 2: Click em ferramentas 
 
Passo 3: Selecione a placa conectada 
 
Passo 4: Selecione a porta COM detectada 
 
Passo 5: Click na seta para direita (Carregar) 
 
 
Quando seu sketche for carregado no microcontrolador do Arduino abra 
o monitor serial clicando no ícone da Loopa conforme imagem abaixo: 
 
Passo 6: Abrindo Monitor Serial 
 
 
Agora observe na imagem abaixo, é isso o que você verá no seu monitor 
serial após carregar o código 
 
 
 
Percebeu que você mandou escrever apenas 1 vez a mensagem “Livro 
sobre Arduino…” porém o programa está imprimindo várias vezes? Isso 
se deve ao que aprendemos sobre a função loop, ela é a responsável de 
repetir sempre os comandos que estiverem entre as chaves de seu void, 
também tem outro ponto que gostaria que observasse, o seu Arduino está 
imprimindo sempre na mesma linha, e se eu quisesse que essa impressão 
fosse sempre em outra linha, ou seja, toda vez que o loop reiniciasse a 
impressão fosse na linha posterior, pois é isso que o próximo tópico irá 
ensinar. 
 
o FunçãoSerial.println() 
A diferença desse comando agora para o anterior é o “ln” no final do 
Serial.print, esse “ln” que forma o comando Serial.println garantirá que a 
próxima vez que o código ver outro comando Serial.print ele será 
impresso na linha abaixo do anterior, vejamos o exemplo abaixo que é o 
mesmo do anterior, apenas adionando o “ln” no comando Serial.print. 
void setup() { 
 Serial.begin(9600); 
} 
void loop() { 
 Serial.println("Livro sobre Arduino..."); 
} 
Agora, após carregar o código em seu Arduino, observe como ficará a 
impressão no Monitor Serial. 
 
Tanto o Serial.print quanto o Serial.println quando recebem dentro de 
seus parênteses uma letra ou palavra que não esteja entre aspas isso 
significa que neles tem uma variável e o que será impresso na tela do seu 
Monitor Serial será o que está carregado na variável escrita, para 
esclarecer vamos entender o que é variável, quais seus tipos e 
especificações técnicas mais à frente no próximo tópico deste livro, no 
momento só acredite q a palavra “frase” contém a mensagem: “Gosto de 
estudar Arduino.”, logo se eu escrever o código abaixo e carregar no meu 
Arduino o que será que vai ser impresso no meu monitor serial? 
 String frase="Gosto de estudar Arduino."; 
void setup() { 
 Serial.begin(9600); 
} 
void loop() { 
 Serial.println(frase); 
} 
 
Observe que agora o que é passado dentro do Serial.print não contém 
mais as aspas, temos a palavra “frase”, porém confira na imagem abaixo 
o que é impresso no Monitor Serial do seu Arduino. 
 
 
Os comandos Serial.print e Serial.println também podem receber um 
parâmetro opcional que possibilitará a formatação do valor que será 
enviado pela porta de comunicação serial, ou seja, por padrão o que é 
enviado é em caracter, como foi dito anteriormente, a linguagem que nós 
humanos entendemos, mas também posso “forçar” o Arduino para que 
quando envie a informação para o computador o faça formatado para uma 
das outras três formas da tabela ASCII que mostramos no tópico anterior: 
BIN, DEC e HEX. Dessa forma a sintaxe ficaria assim: 
 Serial.print(informação, formatação) 
Serial.println(informação, formatação) 
Vamos exemplificar para ficar mais fácil o entendimento: 
 void setup() { 
 Serial.begin(9600); 
} 
 
void loop() { 
 Serial.println(“Testando valores: “); 
 Serial.println(64, BIN); 
 Serial.println(64, DEC); 
 Serial.println(64, HEX); 
} 
 
Após carregar o código, observe o que é escrito em sua tela: 
 
 
 
Volte no livro e confira na tabela ASCII o que representa o número 64 em 
BIN (Binário), DEC (Decimal) e HEX (Hexadecimal), assim confirmamos 
a veracidade e importância da tabela ASCII na vida de um programador. 
 
o Concatenando a função Serial.println() 
Caso eu queira escrever 3 informações em uma linha e após isso quebrar 
a linha, precisarei escrever linhas de código usando o Serial.print e a 
última linha dessa lógica usando o Serial.println, observe o exemplo 
abaixo, agora iremos usar uma variável “x” que nela será carregado um 
valor 4, e o que eu quero que seja impresso é a seguinte frase: “Estudo 
esse livro 4 horas por dia.” 
int x=4; 
void setup() { 
 Serial.begin(9600); 
} 
void loop() { 
 Serial.print("Estudo esse livro "); 
 Serial.print(x); 
 Serial.println(" horas por dia."); 
} 
 
Confira que somente o último Serial.print é que recebe o comando de quebra de 
linha “ln”, agora observe como será impresso no monitor Serial após carregar o 
código. 
 
 
Legal, não é? Mas para isso acontecer eu tive que escrever 3 linhas de código, 
agora vamos aprender a fazer isso em uma linha só, esse método é chamado 
de concatenação de Strings. 
 
Para obter o mesmo resultado, porém usando apenas uma linha de código eu 
preciso entender de concatenação, que é executada com o comando + porém 
tendo que ser escrito entre Strings, ou seja palavras. 
Concatenação é um termo usado em ciências da computação para designar a 
operação de unir o conteúdo de duas ou mais strings. Por exemplo, 
considerando as strings "casa" e "mento" a concatenação da primeira com a 
segunda gera a string "casamento". 
 
Logo, observamos em nosso código que temos uma variável inteira junto com a 
frase que queremos obter, se a concatenação é a operação de unir duas ou mais 
https://pt.wikipedia.org/wiki/Computa%C3%A7%C3%A3o
https://pt.wikipedia.org/wiki/Computa%C3%A7%C3%A3o
https://pt.wikipedia.org/wiki/Opera%C3%A7%C3%A3o
https://pt.wikipedia.org/wiki/Opera%C3%A7%C3%A3o
https://pt.wikipedia.org/wiki/Opera%C3%A7%C3%A3o
https://pt.wikipedia.org/wiki/String
https://pt.wikipedia.org/wiki/String
strings, como faremos para unir também a variável inteira, ou seja o x do meu 
sketche? 
 
Para isso, será necessário aplicar o comando que transforma uma variável do 
tipo inteiro em uma variável do tipo string, sua sintaxe é a seguinte: 
 
String(variável a ser modificada o tipo); 
 
A palavra String, atentar para o “S” maiúsculo, junto com a variável que 
desejamos modificar entre parênteses, gerará um resultado de uma variável 
modificada para o tipo string. 
 
int x=10; //x é uma variável do tipo inteiro que recebe o número 10 
Serial.println(x); //Será impresso 10, porém é 10 em forma decimal 
Serial.println(String(x)); //Será impresso 10, porém é 10 em forma de //cadeia, 
palavra. 
 
Então, alterando o programa anterior, ficaremos com o mesmo resultado porém 
o sketche será assim: 
void setup() { 
 Serial.begin(9600); 
} 
void loop() { 
 Serial.println("Estudo esse livro " + String(x) + " horas por 
dia."); 
} 
Já que estamos falando de variáveis vamos logo conhecer os tipos que mais 
usamos com o Arduino. 
 
● Conhecendo os tipos de variáveis 
 
a) String() 
Formalizando e explicando mais tecnicamente o comando que aprendemos no 
tópico anterior, este comando constrói uma instância da classe String. Ou seja, 
pega uma variável que era de qualquer outro tipo e ao colocá-la dentro dos 
parênteses da String, essa variável que era por exemplo do tipo inteiro (um 
número, como no exemplo anterior) irá se transformar em uma palavra, você 
verá um número, mas para o seu código agora aquilo é uma palavra, ou seja, se 
você posteriormente quiser somar essa variável que você mudou para String o 
código dará um erro, muito importante, duvida? Faz um teste, transforma uma 
variável inteira em string e depois tenta somá-la com outro número. 
Existem várias versões que constroem Strings a partir de diferentes tipos de 
dados (ou seja, formata-os como sequências de caracteres), incluindo: 
 
• uma sequência constante de caracteres, entre aspas duplas (ou seja, uma 
matriz de caracteres) 
 
• um único caractere constante, entre aspas simples 
 
• outra instância do objeto String 
 
• um número inteiro constante ou número inteiro longo 
 
• um número inteiro constante ou número inteiro longo, usando uma base 
especificada 
 
• uma variável inteira ou longa 
 
• uma variável inteira ou longa, usando uma base especificada 
 
• float ou double, usando uma casa decimal especificada 
 
Construir uma String a partir de um número resulta em uma string que contém a 
representação ASCII desse número, lembra da tabela ASCII que apresentamos 
em tópicos anteriores? O padrão é a base dez, por exemplo: 
String thisString = String (13); 
fornece a string "13". 
 
Observe as aspas no número 13, logo já aprendemos outra coisa, que tudo que 
está entre aspas é uma palavra. 
Se após o número tiver uma vírgula é porque não iremos utilizar a base 10 que 
é a padrão, observe a sintaxe e o parâmetro desse tipo de declaração: 
 
Sintaxe 
String (val) 
String (val, base) 
String (val, decimalPlaces) 
 
Parâmetros 
val: uma variável para formatar como uma String. Tipos de dados permitidos: 
string, char, byte, int, long, sem sinal int, sem sinal long, float, double. 
base: (opcional) a base na qual formatar um valor integral. 
decimalPlaces:somente se val for float ou double. As casas decimais desejadas. 
 
b) array 
Um array é uma declaração do tipo matriz que é uma coleção de variáveis que 
serão acessadas com um número de índice. As matrizes podem vir a ser 
complicadas, não a usaremos em nosso curso, por isso não iremos entrar em 
detalhes com esse tipo de variável, aconselho a acessar o site arduino.cc e 
estudar mais sobre esse tipo de variável na aba “referência”, porém o uso de 
matrizes simples é relativamente fácil, veja o exemplo abaixo: 
Todos os métodos abaixo são formas válidas de criar (declarar) uma matriz. 
 
 int myInts [6]; 
• Você pode declarar uma matriz sem inicializá-la como em myInts. 
 int myPins [] = {2, 4, 8, 3, 6}; 
• Em myPins, declaramos uma matriz sem escolher explicitamente um 
tamanho. O compilador conta os elementos e cria uma matriz do tamanho 
apropriado. 
 int mySensVals [6] = {2, 4, -8, 3, 2}; 
• Finalmente, você pode inicializar e dimensionar sua matriz, como em 
mySensVals. 
 char message [6] = "olá"; 
• Observe que, ao declarar uma matriz do tipo char, é necessário mais um 
elemento que a sua inicialização para manter o caractere nulo necessário. 
E para eu ler? O que tem dentro da matriz? 
A referência da matriz inicia no Zero, ou seja, o primeiro elemento dela é 
indexado em zero. Isso também significa que em uma matriz com dez elementos, 
o índice nove é o último elemento. Conseqüentemente: 
int myArray[10]={9, 3, 2, 4, 3, 2, 7, 8, 9, 11}; 
 
Então caso eu queira acessar o índice 9 da minha matriz, que é a posição 10, 
basta escrever o comando abaixo: 
// myArray[9] contains 11 
Caso eu tente acessar o índice 10, será gerado um erro, pois ele não existe 
nessa matriz, existe 10 elementos distribuídos do 0 ao 9. 
// myArray[10] is invalid and contains random information (other memory 
address) 
 
c) bool 
Uma variável bool só contém 2 tipos de valores possíveis, verdadeiro ou falso, 
observe a sintaxe dela logo abaixo. 
 
Sintaxe 
bool var = val; 
 
Parâmetros 
var: nome da variável. 
val: o valor a ser atribuído a essa variável. 
 
d) boolean 
boolean é um tipo não padrão para bool definido pelo Arduino, ele é usado em 
outras linguagens. É recomendável usar o tipo padrão bool, que é idêntico. 
 
e) byte 
A codificação de caracteres que já estudamos neste livro, denominada ASCII 
(American Standard Code for Information Interchange) adotou a informação de 
que 1 byte equivale a 8 bits usando exclusivamente a base binária (valores 0 ou 
1), ou seja, um byte é uma sequência de 8 zeros ou uns, logo isso me retorna 
256 valores diferentes de caracteres para representação de texto nos 
computadores, padronizando desta forma as operações entre diferentes 
dispositivos. 
 
Sintaxe 
byte var = val; 
 
Parâmetros 
var: nome da variável. 
val: o valor a ser atribuído a essa variável. 
 
f) char 
Um tipo de dados usado para armazenar um valor de caractere. Para usar um 
único caracter usa-se aspas simples ‘A’, no caso de vários caracteres juntos 
seria aspas duplas “ABC”. 
 
Os caracteres são armazenados como números, no entanto. Você pode ver a 
codificação específica no gráfico ASCII. Isso significa que é possível fazer 
aritmética em caracteres, nos quais o valor ASCII do caractere é usado (por 
exemplo, 'A' + 1 tem o valor 66, uma vez que o valor ASCII da letra maiúscula A 
é 65). Essa variável causa muita confusão e erros de implementação de códigos 
quando trabalhamos com conexão Bluetooth, por exemplo, quando 
desenvolvemos um aplicativo de celular que controla um carro para frente e para 
trás e nesse aplicativo definimos que para o carro ir para frente será apertado o 
botão verde que irá enviar um dado que programei ser ‘a’, e quando apertar o 
botão vermelho o app irá enviar um dado que programamos ser ‘b’ ao Arduino, 
e lá em nossa placa de Arduino tempos que programá-la de acordo com o que 
o app envia, ou seja, caso o Arduino receba a letra ‘a’ ele irá girar os motores no 
sentido horário movimentando o carro para frente, e caso receba ‘b’ a ação será 
girar o motor no sentido anti-horário fazendo com que o carro se movimente para 
trás, porém, o seu arduino quando receber o carácter ‘a’ que você programou no 
seu aplicativo, na verdade ele irá receber o decimal 97, então para que seu robô 
funcione como o esperado, ele deveria esperar o valor 97, onde é o referente a 
‘a’ na tabela ASCII, que já vimos anteriormente e pelo que você pode perceber 
iremos consultá-la ainda muitas vezes, logo, guarde-a com muito carinho. 
 
O tamanho do tipo de dados char é de pelo menos 8 bits. É recomendável usar 
apenas char para armazenar caracteres 
Sintaxe 
char var = val; 
 
Parâmetros 
var: nome da variável. 
val: o valor a ser atribuído a essa variável. 
 
g) double 
Número de ponto flutuante de precisão dupla, um ponto flutuante é A 
representação em Ponto Flutuante é o modo como o computador representa 
números reais. Por exemplo o número 52,258 é representado na notação 
científica como 0,52258 X 10^2. No Uno e em outras placas baseadas em 
ATMEGA, isso ocupa 4 bytes. 
No Arduino Due, os duplos têm precisão de 8 bytes (64 bits). 
 
Sintaxe 
duplo var = val; 
 
Parâmetros 
var: nome da variável. 
val: o valor a ser atribuído a essa variável. 
 
h) float 
Tipo de dados para números de ponto flutuante, ou seja um número que possui 
um ponto decimal. Números de ponto flutuante são freqüentemente usados para 
aproximar valores analógicos e contínuos porque eles têm maior resolução que 
números inteiros. Os números de ponto flutuante podem ser tão grandes quanto 
3,4028235E + 38 e tão baixos quanto -3,4028235E + 38. Eles são armazenados 
como 32 bits (4 bytes) de informação. Logo não aconselhamos o uso da 
declaração Float quando não for necessário, se você só vai usar números 
inteiros não use float pois ela ocupa mais espaço na memória de seu programa. 
Agora se você está fazendo cálculos matemáticos, é interessante usar o float 
senão seu programa tratará o resultado como numero inteiro no caso de uma 
divisão que gere como resultado uma fração por exemplo. 
Sintaxe 
float var = val; 
Parâmetros 
var: nome variável. 
val: o valor que você atribui a essa variável. 
E por falar em número inteiro vamos ver esse tipo de variável inteiro agora. 
 
i) Int 
Chegamos no tipo de variável que apareceu no programa, o tipo inteiro. 
 
Os inteiros são seu tipo de dados que mais usamos no Arduino, usamos até 
desnecessariamente caindo na mesma condição do float, usamos o int onde 
poderíamos usar o bool que é um tipo de declaração que só recebe dois tipos 
de números, 1 ou 0 (zero).. 
No Arduino Uno (e em outras placas baseadas em ATmega), um int armazena 
um valor de 16 bits (2 bytes). Isso gera um intervalo de -32.768 a 32.767 (valor 
mínimo de -2 ^ 15 e um valor máximo de (2 ^ 15) - 1). Nas placas baseadas em 
Arduino Due e SAMD (como MKR1000 e Zero), um int armazena um valor de 32 
bits (4 bytes). Isso gera um intervalo de -2.147.483.648 a 2.147.483.647 (valor 
mínimo de -2 ^ 31 e um valor máximo de (2 ^ 31) - 1). 
Observe que estamos sempre falando de “armazena um valor”, quando a 
variável excede sua capacidade máxima ou mínima, elas transbordam . O 
resultado de um estouro é imprevisível, portanto, isso deve ser evitado. 
Sintaxe 
int var = val; 
Parâmetros 
var: nome variável. 
val: o valor que você atribui a essa variável. 
 
j) long 
Variáveis longas são variáveis de tamanho estendido, é um qualificador, você 
pode ter uma declaração de um numero e alongar seu armazenamento incluindo 
o “long”. 
Ela armazena 32 bits (4 bytes), de -2.147.483.648 a 2.147.483.647. 
Se estiver fazendo contas com números inteiros, pelo menos um dos números 
deve ser seguido por um L, forçando-o a ser longo. 
 
Vamos fazer um exemplo: 
Digite esse código, carregue em seu Arduino e observe no Monitor Serial que o 
número carregado navariável “x” impressa incrementa até 255 e depois zera 
recomeçando, ou seja, estourou a pilha de armazenamento da declaração tipo 
byte que como vimos no tópico anterior ela varia de 0 a 255. 
byte x=0; 
void setup() { 
 Serial.begin(9600); 
} 
void loop() { 
 x++; 
 Serial.println(x); 
} 
 
Agora inclua o formatador “long” entre a declaração e a varável, você verá na 
impressão na tela, após passar o código, que o valor gerado agora armazena 
números maiores do que 255. 
byte long x=0; 
void setup() { 
 Serial.begin(9600); 
} 
void loop() { 
 x++; 
 Serial.println(x); 
} 
 
k) short 
O “short” é um tipo de variável de dados de 16 bits. 
Em todos os Arduinos (baseados em ATMega e ARM), um short armazena um 
valor de 16 bits ou seja 2 bytes. Isso gera um intervalo de -32.768 a 32.767 (valor 
mínimo de -2 ^ 15 e um valor máximo de (2 ^ 15) - 1). 
Sintaxe 
short var = val; 
Parâmetros 
var: nome variável. 
val: o valor que você atribui a essa variável. 
 
l) string 
String é uma cadeia de textos, usamos ela entre aspas e sempre quando 
quisermos representar uma palavra. 
Exemplo: 
Serial.begin(9600); 
 String frase = "Hoje estou cansado."; 
 Serial.print(frase); 
Pronto caros makers, agora você pode dizer que conhece os principais tipos de 
variáveis usados no Arduino, seguindo em nosso código, a próxima linha entra 
numa função chamada “void”, em especial a “void setup”, então se o programa 
mencionou ela (que sempre vai mencionar) então vamos aprender mais sobre 
essa função. 
 
● Controlando o tempo 
Ação de muita relevância e importância na Robótica, o poder de controlar o 
tempo, precisamos saber administrar o tempo dentro do código, aquele pequeno 
atraso para dar tempo a leitura do sensor, ou o servo-motor concluir seu objetivo, 
e para piscar o led? Preciso intercalar em ligado e desligado, esse intervalo de 
tempo ligado e desligado é alcançado programando o tempo. 
E para nossa sorte a IDE Arduino já traz um pacote incluso com quatro funções 
que me permite controlar o tempo dentro do Sketche, são elas: delay(), 
delayMicroseconds(), micros() e millis(). 
Neste tópico iremos aprender cada uma delas, exemplificar e programar, vamos 
lá. 
o Função delay() 
Pausa o programa pelo período de tempo (em milissegundos) 
especificado como parâmetro dentro dos parênteses. (1000 
milissegundos equivalem a um segundo) 
Sintaxe: 
delay(tempo de pausa em milissegundos) 
Exemplo: 
O código pausa o programa por um segundo antes de alternar o pino de 
saída. 
 
int ledPin = 13; // LED conectado ao pino digital 13 
void setup () { 
 pinMode (ledPin, OUTPUT); // define o pino digital como saída 
} 
void loop () { 
 digitalWrite (ledPin, HIGH); // acende o LED 
 delay (1000); // aguarda um segundo 
 digitalWrite (ledPin, LOW); // desliga o LED 
 delay (1000); // aguarda um segundo 
} 
 
Embora seja fácil fazer um projeto de um LED piscando com a função 
delay() e muitos makers e estudantes usam o delay que querem apenas 
um atraso curto para tarefas como troca de switch, porém não se 
acostume com essa “facilidade”, pois o uso de delay() em um projeto 
apresenta desvantagens significativas. Nenhuma outra leitura de 
sensores, cálculos matemáticos ou manipulação de pinos pode continuar 
enquanto seu sketche estiver parado na linha do delay, durante a função 
de atraso; portanto, na verdade, ela interrompe todo o programa, 
simplesmente ele para ali, e se no caso seu projeto não pode parar de 
monitorar um sensor, fique sabendo que quando você usa o delay o 
restante do código é esquecido naquele momento, logo seu sensor não 
estará sendo monitorado. Por isso que iremos ensinar a técnica millis(), 
último tópico deste capítulo, logo, enquanto não chegamos no millis 
vamos conhecer outra função que também faz atrasar seu programa. 
 
o Função delayMicroseconds() 
Caso você precise de um tempo de espera menor ou fração de 
milissegundos essa função virá no momento certo, o delayMicroseconds 
pausa o programa pela quantidade de tempo (em microssegundos) 
especificada pelo parâmetro. Para eu obter uma pausa de 1 
milissegundos será preciso escrever entre os parênteses o valor 1000. 
Atualmente, o maior atraso preciso é com o valor de 16383, que equivale 
a 16,383 milissegundos ou 0,016 segundos. Isso pode mudar em versões 
futuras do Arduino. Para atrasos superiores a 15000 microssegundos 
aconselhamos você a usar o delay (). 
 
Sintaxe: 
delayMicroseconds(tempo de pausa em microssegundos) 
O parâmetro dentro do parênteses só é permitido se for do tipo unsigned 
int . 
 
Exemplo: 
O código pausa o programa por 100 microssegundos antes de alternar o 
pino de saída. 
 
int ledPin = 8; // LED conectado ao pino digital 8 
void setup () { 
 pinMode (ledPin, OUTPUT); // define o pino digital como saída 
} 
void loop () { 
 digitalWrite (ledPin, HIGH); // acende o LED 
 delayMicroseconds (100); // aguarda 100 microsegundos 
 digitalWrite (ledPin, LOW); // desliga o LED 
 delayMicroseconds (100); // aguarda 100 microsegundos 
} 
 
Esta função só trabalha com segurança de precisão com um valor de 
delay acima de 3 microsegundos, não tente usá-la com valores menores 
que esse. 
 
o Função micros () 
A função micros () não é uma função para ser usada para causar um 
retardo em seu programa, ela na verdade, quando chamada dentro do 
código, retorna o número de microssegundos desde que a placa Arduino 
começou a executar o programa atual. Esse número irá exceder, ou seja, 
voltar a zero, após aproximadamente 70 minutos de placa ligada, ou seja, 
a cada 70 minutos essa contagem reinicia, isso em placas Arduino com 
cristal de 16 MHz como por exemplo, Duemilanove e o Arduino Nano, e o 
valor retornado tem uma resolução de quatro microssegundos (ou seja, o 
valor retornado é sempre um múltiplo de quatro). Já em placas Arduino 
de 8 MHz como por exemplo, o Arduino LilyPad, essa função tem uma 
resolução de oito microssegundos. 
Sintaxe: 
time = micros () 
A variável time deve ser declarada como unsigned long. 
Exemplo: 
O código retorna o número de microssegundos desde que a placa Arduino 
foi inicializada. 
 
unsigned long time; 
 
void setup () { 
 Serial.begin (9600); 
} 
 
void loop () { 
 Serial.print ("Hora:"); 
 time = micros (); 
 Serial.println (time); // imprime o tempo desde o início do //programa 
 delay (1000); // espera um segundo para não enviar grandes 
//quantidades de dados 
} 
 
o Função millis 
A função millis() é semelhante a micros(), porém ela retorna o número de 
milissegundos desde que a placa Arduino começou a executar o 
programa atual. Essa contagem dura bem mais antes da pilha estourar 
(resetar a contagem) esse número só irá exceder, ou seja voltar a zero, 
após 50 dias de placa ligada, ou seja, a cada 50 dias essa contagem 
reinicia contanto que o tipo de variável que irá receber a contagem do 
millis seja declarado como unsigned long, tal qual a função micros. 
 
Sintaxe: 
time = millis() 
A variável time deve ser declarada como unsigned long. 
 
Exemplo: 
O código retorna o número de milissegundos desde que a placa Arduino 
foi inicializada. 
 
unsigned long time; 
 
void setup () { 
 Serial.begin (9600); 
} 
 
void loop () { 
 Serial.print ("Hora:"); 
 time = millis (); 
 Serial.println (time); // imprime o tempo desde o início do //programa 
 delay (1000); // espera um segundo para não enviar grandes 
//quantidades de dados 
} 
 
● Fazendo umas continhas com Arduino 
Ôpa, calma, não precisa fechar o livro, esse livro não é da temida matemática, 
porém ela é fundamental para qualquer atividade em nossa vida e no caso de 
projetos embarcados como a Robótica usando o Arduino não poderia ser 
diferente. 
A IDE Arduino nos disponibiliza alguns comandos que permitem a execução de 
cálculos matemáticos em seu microcontrolador AtMega como por exemplo:Operadores Aritméticos: resto, multiplicação, divisão, adição subtração e 
operador de atribuição. 
 
Funções Matemáticas: Cálculo do valor absoluto, intervalo de valores, regra de 
três, potência, quadrado, raiz quadrada, mínimo e máximo. 
 
Funções Trigonométricas: Cosseno, Seno e Tangente. 
Neste livro não iremos nos aprofundar em todas, iremos estudar as mais usadas 
e que precisaremos para aplicar em nossas prática e projeto final, pois continua 
conosco nessa rica leitura. 
 
o Operadores aritméticos 
( % ) Resto 
A operação resto, também conhecido como módulo, calcula o resto da 
divisão de um número inteiro por outro. Atenção para não confundir o 
símbolo % que se refere ao resto da programação como operador (%) da 
matemática que se refere a divisão, na computação a divisão é é 
calculada através do símbolo ( / ). Tenha atenção também que apesar do 
nome módulo, cuidado para não confundir o módulo do operador (%) da 
computação com o módulo da matemática (| x |), que na linguagem 
arduino é calculada através da função abs (). 
Sintaxe: 
resto = dividendo % divisor 
A variável time deve ser declarada como unsigned long. 
Parâmetros: 
resto: variável. Tipos de dados permitidos: int, float, double 
dividendo: variável ou constante. Tipos de dados permitidos: int 
divisor: variável ou constante diferente de zero. Tipos de dados 
permitidos: int 
Exemplo: 
int x = 0; 
x = 7 % 5; // x agora contém 2 
x = 9 % 5; // x agora contém 4 
x = 5 % 5; // x agora contém 0 
x = 4 % 5; // x agora contém 4 
 
( + ) Adição 
Comando básico da aritmética, simples como na matemática, o símbolo 
de ( + ) escrito entre dois operandos irá realizar a soma desses valores. 
Sintaxe: 
soma = operando1 + operando2; 
Parâmetros: 
soma: variável. Tipos de dados permitidos: int, float, double, byte, short 
e long 
operando1: variável ou constante. Tipos de dados permitidos: int, float, 
double, byte, short e long 
operando2: variável ou constante diferente de zero. Tipos de dados 
permitidos: int, float, double, byte, short e long 
Exemplo: 
A prática apresentada abaixo irá imprimir o valor da soma, variável “c”, 
entre as variáveis “a” e “b” a cada 1 segundo, porém toda vez que o 
programa reiniciar o loop a variável “a” irá receber o valor de “b” e a 
variável “b” irá receber o valor de “c”. 
 
int a = 10; 
int b= 7; 
int c; 
void setup(){ 
 Serial.begin(9600); 
} 
 
void loop(){ 
c = a + b; 
Serial.println(c); 
a=b; 
b=c; 
delay(1000); 
} 
 
Vamos ver como ficaria: 
Segundo 01: 
 a=10, b=7 e c=17 
Segundo 02: 
 a=7, b=17 e c=24 
Segundo 03: 
 a=17, b=24 e c=41 
E assim sucessivamente, legal não é? Então vamos continuar 
desbravando os operadores matemáticos agora com a operação de 
subtração. 
 
( - ) Subtração 
Outro comando básico da aritmética, agora é o oposto da soma, o símbolo 
de ( - ) escrito entre dois operandos irá realizar a subtração desses 
valores. 
 
Sintaxe: 
subtracao = operando1 - operando2; 
 
Parâmetros: 
subtração: variável. Tipos de dados permitidos: int, float, double, byte, 
short e long 
operando1: variável ou constante. Tipos de dados permitidos: int, float, 
double, byte, short e long 
operando2: variável ou constante diferente de zero. Tipos de dados 
permitidos: int, float, double, byte, short e long 
 
Exemplo: 
A prática apresentada abaixo irá imprimir o valor da subtração, variável 
“c” recebe a diferença entre as variáveis “a” e “b” a cada 1 segundo, porém 
toda vez que o programa reiniciar o loop a variável “b” irá ser 
incrementado +1 em seu valor, assim você observará que a resposta “c” 
chegará a um momento em que será negativo, logo a operação de 
subtração pode causar overflow se o resultado é menor que o que pode 
ser armazenado no tipo de dado (ex. subtrair 1 de um int com valor -
32,768 resulta em 32,767). 
 
int a = 10; 
int b= 1; 
int c; 
void setup(){ 
 Serial.begin(9600); 
} 
 
void loop(){ 
c = a - b; 
Serial.println(c); 
b++; //soma mais 1 unidade ao valor que tem em b 
delay(1000); 
} 
 
 
( * ) Multiplicação 
O operador de multiplicação usado na programação Arduino é o ( * ) 
escrito entre dois operandos irá realizar a multiplicação desses valores. 
 
Sintaxe: 
multiplicação = operando1 * operando2; 
 
Parâmetros: 
multiplicação: variável. Tipos de dados permitidos: int, float, double, 
byte, short e long 
operando1: variável ou constante. Tipos de dados permitidos: int, float, 
double, byte, short e long 
operando2: variável ou constante diferente de zero. Tipos de dados 
permitidos: int, float, double, byte, short e long 
 
Exemplo: 
Observe o exemplo abaixo, iremos multiplicar duas variáveis do tipo float, 
porém o resultado eu declarei como int, logo o número fracionário que 
esperávamos será descartado e será mostrado apenas a parte inteira. 
 
float a = 10.2; 
float b= 2.3; 
int c; 
c= a*b; // O resultado esperado seria 23,46, porém será armazenado 
apenas o valor 23 
 
( / ) Divisão 
O operador de divisão usado na programação Arduino é o ( / ) escrito 
entre dois operandos irá realizar a multiplicação desses valores. 
 
Sintaxe: 
divisão = numerador / denominador; 
 
Parâmetros: 
divisão: variável. Tipos de dados permitidos: int, float, double, byte, 
short e long 
numerador: variável ou constante. Tipos de dados permitidos: int, float, 
double, byte, short e long 
denominador: variável ou constante diferente de zero. Tipos de dados 
permitidos: int, float, double, byte, short e long 
Atenção: O denominador não pode ter valor zero. 
 
Exemplo: 
float a = 10.2; 
float b= 2.3; //pode ser qualquer valor diferente de zero 
int c; 
c= a / b; 
 
o Calculando a potência 
Lembra do elevado ao quadrado da matemática? Pois isso é um número 
elevado a potência 2 e é exatamente isso que a função pow() faz, ela 
calcula o valor de um número elevado a uma potência. pow () também 
pode ser usado usado para aumentar um número para uma potência 
fracionária, que nesse caso seria uma raiz, também serve para gerar 
mapeamento exponencial de valores ou curvas, como medidas de 
temperaturas usando termistores. 
 
Sintaxe: 
pow(base, expoente); 
 
Parâmetros: 
base: o número. Tipos de dados permitidos: float. 
expoente: a potência ao qual a base é elevada. Tipos de dados 
permitidos: float 
 
Exemplo: 
z=pow (x , y); 
 
o Calculando a raiz quadrada 
A função sqrt() calcula a raiz quadrada de um número, que na 
matemática, a raiz quadrada de um número “x” é um número único e não 
negativo que quando multiplicado por si próprio se iguala ao número “x”. 
 
Sintaxe: 
sqrt(x); 
 
Parâmetros: 
x: o número. Tipos de dados permitidos: qualquer tipo de dados. 
 
Exemplo: 
z=sqrt(x); 
 
 
● Brincando de sortear 
 
o Função random() 
 E para encerrar nossa primeira parte do livro de conceituação na 
programação Arduino, temos a função random(), usando ela o programa 
gera falsos sorteios de números, por que falamos de falsos sorteios? Na 
verdade a função é programada para iniciar sempre com o mesmo valor 
a partir deste, ir gerando valores “aleatórios”. 
Sintaxe: 
random(max); 
random(min, max); 
Parâmetros: 
min: limite inferior do valor aleatório, entra no sorteio. 
max: limite superior do valor aleatório, não entra no sorteio. 
 
Exemplo: 
long sorteio; 
 
void setup () { 
 Serial.begin (9600); 
 randomSeed (analogRead (0)); 
} 
 
void loop () { 
 // imprime um número aleatório de 0 a 999 
 sorteio = random (1000); 
 Serial.println (sorteio); 
 
 // imprime um número aleatório de 35 a 54 
 sorteio = aleatório (35, 55); 
 Serial.println (sorteio); 
 
 delay (50); 
} 
 
Lembra do que falamos no início deste tópico? De que a função random() 
sempre inicia com um mesmo número? Pois bem, para resolver esse 
impasse podemos chamar no setup a função randomSeed(), esta função 
gera números “sementes” diferente, assim a cada reinicializaçãodo 
Arduino a função random irá iniciar com um número diferente de 
sequência de sorteio. 
 
Agora tire seus componentes do Organizador e vamos começar a montar 
projetos. 
 
Capítulo 03 – Arduíno controlando as coisas 
 Ligando as coisas no Arduino 
Só fazer o Arduino processar e apresentar as informações em nossa tela não é o 
objetivo dessa super placa, sua criação e desenvolvimento foi para integrar a 
programação para ligar e movimentar as coisas em nosso meio com suas portas de 
entrada e saída conforme estudamos em tópicos anteriores. Essas portas são o meio 
de comunicação entre o processador e o mundo fora dele, tudo que você programar no 
AtMega328P, processador do Arduino UNO por exemplo, e definir alguma ação nessas 
portas ela será obedecida pelo Arduino e a mágica acontecerá. 
Comparando com uma pessoa, é como se nós fossemos o Arduino, nosso cérebro o 
processador, o AtMega por exemplo, nossas articulações os motores e nossos olhos 
as portas definidas na programação Arduino como entrada e nossa boca a porta 
definida na programação Arduino como uma porta de saída. Na porta de entrada que 
declaramos como olhos, temos sensores tipo cameras e na porta de saída que 
declaramos tipo boca temos um alto-falante conectados, logo podemos fazer um 
pseudocódigo da seguinte forma: 
se (olhos==fantasma){ 
execute(boca, GRITE); 
} 
E é exatamente nessa lógica que iremos programar a partir de agora, vamos lá. 
● Entradas e saídas digitais. 
Já vimos em tópicos anteriores que as portas do Arduino são de entrada ou saída 
de dados variando de acordo com o modelo da placa, iremos trabalhar com o 
Arduino UNO, onde ela tem 20 portas de entrada e saída de dados sendo 6 
portas Analógicas e 14 portas para informações digital. 
 Funcionando o LED 
Como vimos em tópicos anteriores, oLED é um diodo emissor de luz, possuindo, 
em nosso primeiro projeto, duas “pernas”, onde a maior deve ser conectada na 
porta do Arduino e a menor no GND. Considero o LED o componente mais 
importante da Robótica, pois com ele posso simular qualquer situação em que 
eu não teria o componente, por exemplo, se desejo que meu projeto aciona uma 
bomba d’agua, e naquele momento não tenho essa bomba, poderei simulá-la 
usando um led, onde ele iria ascender na situação em que seria para ligar a 
bomba, então vamos aprender a controlar esse tal de LED. 
● Piscando um LED - Função digitalwrite() 
Primeiro vamos montar nosso circuito, como devo considerar que você leu os 
capítulos anteriores e tem o conhecimento do Hardware do Arduino e como é o 
LED e para que serve o resistor, você deve montar o seu circuito conforme 
imagem abaixo, dúvidas poderá ser enviado um email para o autor deste livro 
contato@profsandromesquita.com. 
mailto:contato@profsandromesquita.com
 
 
A prática Pisca Led é a porta de entrada para o Arduino, prática clássica que até 
já vem como exemplo no programa da IDE, logo, decidimos mostrar aqui no blog 
(exclusivo aqui, não tem no vídeo que você assistiu) três formas diferentes de 
piscar o Led...Antes de começar monte seu hardware de acordo com a imagem 
acima: 
 
Um resistor de 330 Ohm ligado a porta 13 do Arduino que por sequencia liga-se 
o outro terminal do resistor na "perna" positiva (anodo) do seu Led, e a perna 
negativa (Catodo) você ligaria no GND do Arduino, observe a imagem mais 
detalhada de um LED logo abaixo: 
 
Este é o programa inicial do Arduíno, o famoso "Olá Mundo" da programação é 
feito com o piscar Led no Arduino. Essa saudação entre o Arduíno e o meio 
exterior é feita comumente usando essa Lógica De Programação onde se 
escreve um passo a passo de cada estado estado do Led. 
 
 
 
A primeira linha, int LED=13; declara ao Arduíno que a variável LED é do tipo 
inteira e está ligada na porta 13 do Arduino. Já dentro da função void setup() o 
comando pinMode(LED,OUTPUT); configura a porta 13 do Arduino como uma 
porta de saída, tendo em vista que por padrão de fábrica todas as portas são 
configuradas como entrada, logo se faz necessário o uso desse comando. Até 
esse ponto será padrão para os 3 modos de controle da atividade de piscar o 
Led, a partir da função void loop() é que difere uma lógica da outra. 
 
 No void loop() temos 4 linhas de programação escrita, o comando 
digitalWrite(LED, HIGH); que eleva a porta 13 do Arduino para nível lógico alto 
(5v) ligando o Led, em seguida o chamado delay(1000); para a programação 
por 1 segundo mantendo o estado do Led ligado por esse período de tempo, 
logo o Led se apaga pois o comando digitalWrite(LED, LOW); baixa o nível 
lógico da porta para 0 (0v) e novamente espera 1 segundo com o comando 
delay(1000); 
 
A segunda forma que gostaria de apresentar da Prática Pisca LED invertendo o 
status da variável que está declarada...como assim? Calma..continue lendo este 
livro que você vai entender que você vai entender. 
 
 
Nessa lógica de piscar o Led, usamos uma programação mais refinada e com 
isso economizamos uma linha de programação e a aparência do programa 
parece ser mais agradável e organizada, ela funciona assim: a variável estado 
recebe valor inicial zero nas declarações de variáveis no início do programa 
(nível lógico baixo) e como ela está escrita no segundo parâmetro do comando 
digitalWrite(LED, estado); ele irá receber o valor que está carregado nessa 
variável, ou seja desligar o Led, após esse comando o programa espera 1 
segundo no delay(1000); e em seguida inverte o sentido da variável estado com 
o comando !estado e em seguida carrega esse novo valor invertido na variável 
estado com o comando estado=!estado assim quando chegar novamente no 
digitalWrite(LED, estado); o Led inverterá seu estado de desligado para ligado, 
por exemplo. 
 
A última forma que quero apresentar de Piscar o LED é lendo o status do LED 
na própria função que executa a ação de piscar, vamos ver como é: 
 
 
 
Para concluir esta primeira interação do Arduino como mundo exterior apresento 
a terceira forma de realizar o projeto de piscar o Led, e para isso iremos aprender 
a usar o comando digitalRead(); que é quem realizada a leitura em uma 
determinada porta digital do Arduino. A diferença desse programa para os dois 
mostrados anteriormente é que dentro do comando digitalWrite(LED, 
!digitalRead(LED)); no lugar da variável estado usa-se o comando de leitura da 
porta digital digitalRead();, ou seja, o Arduíno verifica o estado atual da porta e 
inverte o estado dela, de 0 para 1 por exemplo, toda vez que entrar na função 
usando o comando ! antes do digitalRead(LED); sempre esperando um 
segundo a cada execução dessa linha. Esse programa fica mais enxuto e 
inteligente sendo considerado um programa bem escrito. 
 
 Revisando os comandos que aprendemos nesse post : 
● digitalWrite(porta,estado): responsável por escrever em uma porta digital 
● digitalRead(porta); responsável por ler em uma porta digital 
● delay(atraso); responsável por realizar um atraso no programa 
● pinMode(porta,modo); responsável por configurar a porta do Arduino com saída 
 
● Oscilando um LED - Função analogwrite() 
Além do comando binário (que só atende 2 estados, 1 ou 0, ligado ou desligado) 
aplicado ao LED, pode também controlar o seu nível de luminosidade, como 
vimos na pinagem do Arduino no Capítulo anterior, através das portas especiais 
3, 5, 6, 9, 10 e 11, que são portas PWM o Arduino pode “transformar” a saídas 
destas portas que seriam digitais em analógica criando um pulso com modulação 
em cada porta destas citadas acima, e o que é essa Modulação por Largura de 
Pulso conhecido como PWM (Pulse Width Modulation)? 
 
PWM (Pulse Width Modulation) 
PWM é o conceito de pulsar rapidamente o sinal digital na saída da porta do 
Arduino, lembra que estudamos que do pino 0 ao 14 do seu Arduino são portas 
de entrada ou saída digital, ou seja, adotam dois possíveis valores, zero ou um, 
que equivale a ligado ou desligado,que eletricamente testando na saída das 
portas teremos 0v ou 5v para o Arduino UNO por exemplo, pois bem e se nessa 
saída eu quiser uma tensão de 2,5v, ou seja, quero produzir um “meio termo”, 
nem ligado total, nem desligado, como farei isso se a porta não é analógica e 
sim digital? 
 
É nesse momento que entra nosso amigo PWM que é uma Modulação por 
Largura de Pulso, seria como o seu Arduino fosse enviar um código Morse, onde 
para cada frequência de bips dentro de um intervalo de tempo significaria uma 
letra. A técnica PWM é comumente aplicada no controle de motores elétricos, 
aquecedores, lâmpadas e Led’s por exemplo, onde justamente será um dos 
exemplos adotados em nosso livro, o controle PWM para um LED e outro para 
um motor CC. 
 
Então já sabendo que o PWM é a técnica usada para gerar sinais analógicos do 
Microcontrolador AtMega de seu Arduino e sabendo de sua importância e 
eficiência nos dias de hoje, neste capítulo vamos aprender os conceitos básicos 
desta técnica e como ela é aplicada no controle do brilho do LED usando o 
Arduino. 
 
Ao gerar circuitos analógicos de forma digitalmente, os custos do sistema e o 
consumo de energia podem ser drasticamente reduzidos. Um exemplo atual é o 
uso do inverter no ar-condicionado, comprovada redução no consumo de 
energia em relação aos aparelhos tradicionais. Devido à eficiência deste tipo de 
controle, muitos microcontroladores já incluem controladores PWM no chip, 
facilitando esta implementação. 
 
O sinal PWM é totalmente digital porque em qualquer dado instante de tempo, a 
alimentação CC ou está totalmente ligada ou completamente desligada. Porém 
o processo de ligar e desligar dentro de um intervalo de tempo é que forneceria 
para a carga um sinal analógico, por exemplo, olhe agora para o interruptor da 
lâmpada de onde você está, se ele estiver ligado, sua lâmpada estará acesa, 
caso contrário estará desligada, isso é um sinal digital, ou ligado ou desligado, e 
quando liga ela produzirá sua capacidade de luz máxima. Agora experimente 
ligar e desligar bem rápido o interruptor, você verá uma sensação de meia luz, 
porém devido nossa limitação motora ainda perceberemos o processo da luz 
apagando e acendendo, agora imagine isso sendo feito por um processador na 
frequência certa e tempo certo, teremos o efeito perfeito do que simulamos com 
o interruptor da lâmpada, isso é uma modulação PWM. 
A Figura abaixo mostra três sinais PWM diferentes sendo que a primeira mostra 
uma saída PWM a um ciclo de trabalho de 75%. Ou seja, o sinal está ligado para 
75% do período e desligado nos outros 25%. As Figuras 2 e 3, logo abaixo, 
mostram as saídas PWM a ciclos de trabalho de 50% e 20%, respectivamente. 
Estas três saídas PWM codificam três diferentes valores de sinal analógico, a 
75%, 50% e 25% da energia de entrada. Como no exemplo a alimentação é de 
5V, observe na imagem o quanto de tensão é fornecido para cada ciclo de 
trabalho. 
 
https://www.slideserve.com/ian-willis/aula-06-sinais-anal-gicos 
 
Vamos começar então a nossa prática, como vamos montar uma prática de 
variar o brilho do LED de forma gradual iremos precisar dos seguintes 
componentes: 
- 01 Arduino UNO (pode ser outro) 
- 01 LED de alto brilho Azul (pode ser qualquer outra cor) 
- 01 Resistor de 470 Ohm 
- 02 Cabos Jumper 
- 01 Protoboard de 400 furos (pode ser menor) 
Com os componentes na mão siga a montagem de acordo com o esquema 
desenhado abaixo: 
https://www.slideserve.com/ian-willis/aula-06-sinais-anal-gicos
 
 
Quando você montar o seu projeto deve ficar parecido com o desta foto abaixo: 
 
 
Agora chegou a hora de programar seu Arduino para ligar esse LED de uma 
forma gradual e continua, ligando e desligando variando seu brilho 
gradualmente, então abra sua IDE e vamos começar. 
 
[code] 
/* 
 * Uso do PWM com LED 
 * Aumentando e diminuindo a 
 * intensidade do brilho do LED 
 */ 
int led=3; //Nomeando a porta 3 como led 
 //A porta 3 do Arduino é PWM 
void setup() { 
 pinMode(led,OUTPUT);//Define o pino do led 
 //como porta de saída 
} 
 
void loop() { 
 //Sequência de ligar o led gradualmente 
 for (int brilho=0; brilho<=255; brilho++){ 
 analogWrite(led, brilho); //Envia para o led 
 //um valor analógico 
 delay(15);//Aguarda 20 milissegundos p/ aumentar 
 } 
 //Sequência de ligar o led gradualmente 
 for (int brilho=255; brilho>=0; brilho--){ 
 analogWrite(led, brilho); //Envia para o led 
 //um valor analógico 
 delay(15);//Aguarda 20 milissegundos p/ diminuir 
 } 
} 
[/code] 
 
O que temos de novo neste código é a estrutura de repetição for, ela é 
responsável por deixar o programa preso nesse loop pela condição determinada 
no segundo parâmetro de sua especificação, onde compara se a condição 
atingiu seu valor, vamos explicar melhor pra você entender. 
 
Vamos supor que você desobedeceu sua mãe e ela falou assim: 
- Você vai ficar de castigo no canto da parede por 10 horas! 
Então, para você não ficar de castigo por mais tempo que o determinado pela 
mamis, você a cada hora olha pro relógio e compara, "O tempo que estou de 
castigo é menor ou igual a 10? Se for, preciso continuar no canto da parede, se 
for 11 já posso sair desse castigo." 
O "castigo" é o laço de repetição for que vai lhe deixar no canto da sala até que 
a variável determinada seja atingida, que no nosso caso será uma variável inteira 
"brilho", então bora entender o que é esse tal de Laço FOR falando 
tecnicamente: 
 
A instrução FOR é usada para repetir um bloco de instruções entre chaves. Um 
contador de incremento é geralmente usado para incrementar e finalizar o loop 
sendo útil para qualquer operação repetitiva inclusive variação da tensão na 
porta de saída do Arduino que será a prática deste tópico. 
 
A Syntax é assim: 
for (valor inicial; condição final; o quanto de incremento) { 
 // o que você quiser fazer ponha aqui 
} 
 
valor inicial: acontece primeiro e somente uma vez. 
condição final: cada vez que o loop é testado; se for verdade, o bloco de 
instruções e o incremento forem executados, a condição será testada 
novamente. Quando a condição se torna falsa, o loop termina. 
o quanto de incremento: executado sempre através do loop quando a condição 
for verdadeira. 
 
Então como a porta PWM fornece um valor que varia de 0 a 255, onde zero em 
PWM é 0V em tensão no LED e 255 em PWM é 5V em tensão no LED, a cada 
vez que o programa entrar no for ele irá somar +1 na variável brilho até atingir o 
valor 255 e sair desse laço for e partir para a próxima condição de nosso sketch, 
que é agora a lógica inversa, diminuir o brilho do LED. 
 
Vamos fazer outra prática com laço FOR agora variando as portas do Arduino 
no próximo tópico, assim aprenderemos mais sobre essa estrutura de repetição 
tão usada em nossos projetos com Arduino. 
 
● Montando uma sequência de LEDS 
 
O esquema de montagem de nosso projeto será igual ao da imagem acima 
desenvolvido no fritzing, caso você não saiba o que é e nem como instalar o 
Software Fritzen, volte alguns capítulos deste livro, pois publicamos os links dos 
softwares que precisamos em nossas práticas. 
A ideia é que o se inicie uma sequência de LED’s ligados, ligando primeiro o LED 
verde, após 1 segundo desliga-o e liga o LED amarelo, fazendo o mesmo 
processo quando se passar mais um segundo, desligando agora o LED amarelo 
e ligando o LED branco, se repetindo o ciclo até que o Arduino seja desligado ou 
resetado. 
A programação é simples, usaremos a estrutura de repetição FOR que 
aprendemos no tópico anterior, porém como sempre temos que aprender uma 
coisa nova, vamos aplicar o conhecimento do FOR na configuração das portas 
do Arduino, sabe onde é? Lembra do comando usado? Sim, acertou, no 
pinMode, se não entendeu, tenha calma,vamos ver o código abaixo e você irá 
compreender o que estou falando. 
 
/* 
 * Esse código liga uma sequência de leds 
 * Objetivo: reforçar o uso do laço FOR de repetição 
 */ 
void setup() { 
 for(int x=2; x<=4; x++){ 
 pinMode(x,OUTPUT); //Declara as portas como saída de forma automática 
 } 
} 
 
void loop() { 
 for(int x=2; x<=4; x++){ 
 digitalWrite(x,HIGH); //Liga LED referente a porta incrementada em x 
 
 if(x==2){ 
 digitalWrite(4,LOW); //Se o LED a ser ligado for o do pino 2, desliga o último 
LED do projeto que seria o 4 
 } 
 else{ 
 digitalWrite(x-1,LOW); //Se o LED não for o do pino 2, desliga o anterior a ele 
 } 
 delay(1000); 
 } 
} 
 
O programa é simples, o FOR inicia com o x recebendo o número inteiro 2, 
significando que a porta 2 do Arduino ao qual está conectado o LED verde, 
quando o programa entrar pela primeira vez nesse laço FOR vai ligar o LED 
verde através do comando digitalWrite(x,HIGH); como sabemos que o x é 2, logo 
irá ligar o led que estiver na porta 2, que mais uma vez sabemos que é o LED 
verde, a próxima linha é testar se o x é igual a 2, esse comando é necessário 
devido a nossa lógica que optamos neste projeto que é ligar um LED e desligar 
o anterior a ele, como a porta anterior é a porta 1 do Arduino e não temos LED 
conectado nela, e sim na porta 4, onde na lógica esse é o LED anterior ao Verde, 
pois como vimos na explicação é o último LED da sequência, e quando ele 
desligar o próximo na sequência seria reiniciar o ciclo, ou seja ligando o primeiro 
LED, que está na porta 2, logo, caso o x seja igual a 2, o LED a ser desligado 
será o 4 é isso que a condicional IF que já estudamos faz. Senão, ou seja, se o 
x não for igual a 2 (else), iniciamos outra parte do código que é a sequência 
natural e automática, ou seja, desligar o LED anterior ao x. Por exemplo, quando 
o seu código voltar para o início do loop, o valor do x não será mais 2, ele terá 
sido incrementado com +1 de acordo com o que escrevemos no parâmetro FOR 
(for(int x=2; x<=4; x++), lembrando que x++ é a mesma coisa de x=x+1, logo 
agora o x vale 3, então vamos depurar o código e seguir o passo a passo? 
 
void loop() { 
 for(int x=2; x<=4; x++){ //x=3 
 digitalWrite(x,HIGH); //Liga o LED Amarelo 
 if(x==2){ //x não é igual a 2, então não entra 
 digitalWrite(4,LOW); //Não faz nada porque não entrou aqui 
 } 
 else{ 
 digitalWrite(x-1,LOW); //x-1=2, logo desliga o LED Verde 
 } 
 delay(1000); //Espera 1 segundo 
 } 
} 
Deu pra entender? Legal não é? Então vamos avançar, vamos trocar o LED, 
agora vamos usar um LED RGB, tá curioso? Quer aprender o que é um LED 
RGB? Então continue lendo este livro. 
 
● Aprendendo sobre o LED RGB 
No início deste livro estudamos sobre o LED RGB, que tal agora aprendermos a 
programá-lo com o Arduino? Para isso vamos revisar as suas “pernas” e depois 
ver o forma de ligar no Arduino. 
 
O seu nome RGB vem das iniciais das cores primárias que esse LED pode 
assumir, R - Red, G - Green e B - Blue, se você observar na imagem acima a 
sequência é sempre a mesma para os dois modelos, o que muda é se o pino 
comum (perna maior) será conectado no positivo ou negativo. Da esquerda para 
a direita tomando como referência a maior perna para o lado esquerdo teremos 
a sequência: 
Vermelho | (Vcc ou GND) | Verde | Azul 
Caso a “perna” comum seja GND as “pernas” RGB terão que receber sinal 
positivo para ligar na perna que você quer que ligue a cor desejada, já no caso 
da “perna” maior, que é a comum, seja VCC, positivo, para ligar cada cor será 
necessário ligar as RGB na tensão 0V, ou seja, GND. 
Vamos montar esse LED RGB na Protoboard e ver como fica essa “confusão” 
no Arduino, confusão agora, você vai ver como é fácil. 
 
Para programarmos o RGB precisamos seguir uma tabela de valores analógicos 
para cada cor que ele pode produzir, pois esse componente não apenas emitirá 
as cores Vermelho, Verde e Azul como seu nome sugere, e sim qualquer cor 
que possa ser gerada com a misturas destas 3 primárias, observe a tabela 
abaixo a partir dela iremos montar nosso código. 
 
Observe que os valores a serem escritos nas portas que estará conectado as 
pernas do LED será um valor analógico que irá variar de 0 a 255 (faixa de 
operação da onda PWM), então admitindo que conectamos nosso LED RGB nas 
portas 2, 3 e 4 respectivamente seguindo o padrão de cores e que o seu pino 
comum é GND, iremos escrever nosso código agora seguindo o que 
aprendemos e combinamos até aqui. 
/* 
 * Desenvolvedor: Sandro Mesquita 
 * Data: 17/01/2020 
 * Projeto: Controle LED RGB 
 * Publicado: Livro 
 */ 
//Declara as portas dos pinos do LED RGB 
int pinRed=2, pinGreen=3, pinBlue=4; 
 
void setup() { 
 for (int pinOut=2; pinOut<=4; pinOut++){ 
 pinMode(pinOut, OUTPUT); //Configura com saida do pino 2 ao 4 
 } 
} 
 
void loop() { 
 //COR VERMELHA 
 analogWrite(pinRed, 255); 
 analogWrite(pinGreen, 0); 
 analogWrite(pinBlue, 0); 
 delay(500); 
 //COR AMARELA 
 analogWrite(pinRed, 255); 
 analogWrite(pinGreen, 127); 
 analogWrite(pinBlue, 0); 
 delay(500); 
 //COR LARANJA 
 analogWrite(pinRed, 255); 
 analogWrite(pinGreen, 255); 
 analogWrite(pinBlue, 0); 
 delay(500); 
 //COR VERDE 
 analogWrite(pinRed, 0); 
 analogWrite(pinGreen, 255); 
 analogWrite(pinBlue, 0); 
 delay(500); 
 //COR AZUL 
 analogWrite(pinRed, 0); 
 analogWrite(pinGreen, 0); 
 analogWrite(pinBlue, 255); 
 delay(500); 
 //COR ROXA 
 analogWrite(pinRed, 75); 
 analogWrite(pinGreen, 0); 
 analogWrite(pinBlue, 130); 
 delay(500); 
 //COR VIOLETA 
 analogWrite(pinRed, 143); 
 analogWrite(pinGreen, 0); 
 analogWrite(pinBlue, 255); 
 delay(500); 
} 
Detalhando o código acima, não encontramos nenhum comando que já não 
tenha sido apresentado, mas vamos revisar algumas funções. 
//Declara as portas dos pinos do LED RGB 
int pinRed=2, pinGreen=3, pinBlue=4; 
Nesta primeira linha temos a declaração das portas do Arduino correspondente 
aos pinos do LED RGB ao qual estão instaladas, o pino referente a cor Vermelha 
está conectado na porta 2 do Arduino, o verde na 3 e o azul na 4, a sequência 
das “pernas” do LED está na imagem um pouco antes ainda neste tópico. 
void setup() { 
 for (int pinOut=2; pinOut<=4; pinOut++){ 
 pinMode(pinOut, OUTPUT); //Configura com saida do pino 2 ao 4 
 } 
} 
Na função void setup() estamos configurando as portas como saída (OUTPUT) 
usando nosso conhecimento em estrutura de repetição for . 
void loop() { 
 //COR VERMELHA 
 analogWrite(pinRed, 255); 
 analogWrite(pinGreen, 0); 
 analogWrite(pinBlue, 0); 
 delay(500); 
…} 
O void loop() é a função principal de nosso código, nela é onde vai acontecer a 
mágica do LED ficar alterando sua cor, programamos para acender as cores 
vermelha, amarela, laranja, verde, azul, roxa e violeta, seguindo a tabela de 
cores publicada neste livro neste mesmo capítulo em linhas atrás. Caso queira 
conhecer outras cores para configurar seu LED RGB basta pesquisar na internet 
“tabela de cores LED RGB”. 
Tá, mas até agora as coisas funcionaram de forma automática, e se eu quiser 
controlar de fora, não apenas uma sequência pré programada do meu 
computador, eu posso usar algo externo ao Arduino que ligue e desligue um LED 
por exemplo? A resposta está no próximo capítulo, vamos lá? 
 
Lendo as portas do Arduino 
 Para você usar este recurso do Arduino você precisa aprender alguns comandos 
como: 
pinMode(porta, INPUT); 
pinMode(porta, INPUT_PULLUP); 
digitalRead(porta); 
analogRead(porta); 
entre outros comandos, então vamos começar a conhecer e entender cada uma dessas 
funções que a IDE do Arduino nos oferece como ferramenta de programação. 
● E se acontecer alguma coisa? O que devo fazer? – Condicional IF 
O condicional if () já foi estudadoem tópicos anteriores, agora vamos usar essa 
condição para executar algo quando uma ação externa acontecer nas portas do 
Arduino e para começar vamos usar o sensor mais comum e frequente em 
qualquer projeto de robótica ou automação, vamos usar o push button ou 
traduzindo, botão de pressão. 
O botão conhecido no mundo maker como Push Button é uma chave de pressão 
que mantém o contato elétrico fechado enquanto estiver pressionando, ao soltar 
o botão desconecta os contatos pela ação da força da mola, o modelo mais 
usado em projetos é o da figura abaixo: 
 
Iremos mostrar o modelo acima por ele conter 4 “pernas”, onde essa 
característica muitas vezes confunde a forma montar no circuito, os modelos que 
só tem duas “pernas” já tem uma instalação mais simples e intuitiva, observe a 
imagem abaixo da Chave Táctil desenhada a sua estrutura interna. 
 
Observe que o Pino A é ligado “direto” com o Pino B, valendo a mesma estrutura 
entre o Pino C e o Pino D, ou seja, a ligação para o perfeito funcionamento do 
botão é em “X”, a ligação deve ser feita cruzada ligando o terminal A com o D ou 
o terminal C com o B, esse detalhe é muito importante, muitas pessoas se 
confundem e realizam a montagem do botão de forma errada no projeto. 
 
No caso de dúvidas, você pode testar qual as pernas tem continuidade (ligado 
direto) e qual é referente a função táctil, observe a forma correta de testar. 
 
Conecte a ponta de prova positiva em uma perna do botão e a ponta de prova 
negativa na outra perna, ajuste o seu multímetro para escala de resistência ou 
continuidade, no caso da continuidade quando a ligação for feita o multímetro 
não faz nada, ao ser pressionado o botão o multímetro irá produzir um som, um 
beep. No caso da imagem acima, onde ajustamos o multímetro na função 
Resistência, quando o botão não estiver pressionado será lido pelo multímetro 
uma valor muito elevado de resistência, na situação 2, imagem a direita, ao 
pressionar o seu multímetro irá para zero, pois o contato foi estabelecido e a 
corrente elétrica irá passar livremente, sem resistência. 
 
o Aprendendo botão com delay() 
Vamos usar botão para ligar e desligar o LED, o grande problema do 
botão é que ao ser pressionado o seu toque para para você parece ser 
único para o Arduino ocorreram milhares de interrupções, ele detectou 
vários sinais de entrada em sua porta digital, para resolver isso, de uma 
forma não profissional, ainda, iremos usar a função delay, para retardar 
um pouco o programa e essa oscilação que chamamos de debouncing se 
estabilize. 
Vamos montar o nosso circuito de acordo com a imagem abaixo: 
 
Com o seu Led conectado na porta 8 do Arduino e o botão na porta 9 
podemos escrever o código de acordo com a montagem, vamos lá: 
/* 
 * Desenvolvedor: Sandro Mesquita 
 * Data: 21/01/2020 
 * Projeto: Ligando LED com Botão 
 * Publicado: Livro 
 */ 
int botao=9, ledVerde=8; 
bool estadoLed=0; 
void setup() { 
 pinMode(ledVerde, OUTPUT); 
 pinMode(botao, INPUT_PULLUP); 
} 
 
void loop() { 
 int estadoBotao=digitalRead(botao); 
 delay(200); 
 if(estadoBotao==0){ 
 estadoLed=!estadoLed; 
 digitalWrite(ledVerde, estadoLed); 
 } 
} 
Explicando o void loop() vemos que na primeira linha o comando 
digitalRead(botao) lê o estado que a porta 9 do Arduino está, se em nível 
lógico alto (quando o botão não está pressionado) devido a configuração 
pinMode(botao, INPUT_PULLUP); feita no void setup() ou se está em 
nível lógico baixo, ou seja, lendo zero. Logo o valor lido é armazenado na 
variável int estadoBotao e logo em seguida testado pela condicional 
if(estadoBotao==0), onde se for pressionado irá entrar na condicional e 
executar a mudança do estado atual do LED, onde se estava ligado irá 
desligar e se estava desligado irá ligar, isso é garantido devido o comando 
estadoLed=!estadoLed; onde nada mais é do que inverter o valor 
booleano que carrega esta variável, onde inicialmente foi declarado com 
valor zero, e a cada entrada nesta condicional irá inverter, como na função 
digitalWrite(ledVerde, estadoLed); a variável estadoLed está dentro do 
parâmetro referente a acionar o Led, se esta variável carregar o valor 1 
irá ligar o Led, porém se ela carregar o valor zero irá desligar. 
Simples não é? Agora esse código tem um problema, caso você fique 
pressionando o botão o Led irá ficar piscando, e isso não é legal 
dependendo do projeto, logo vamos melhorar esse código, onde se eu 
permanecer pressionando o Led não altere o seu estado, só faça isso no 
próximo pressionamento. 
 
o Melhorando o uso do botão com debounce 
/* 
 * Desenvolvedor: Sandro Mesquita 
 * Data: 21/01/2020 
 * Projeto: Ligando LED com Botão só 1x 
 * Publicado: Livro 
 */ 
int botao=9, ledVerde=8; 
bool estadoLed=0, estadoAnterior=1; 
void setup() { 
 pinMode(ledVerde, OUTPUT); 
 pinMode(botao, INPUT_PULLUP); 
} 
 
void loop() { 
 int estadoAtual=digitalRead(botao); 
 delay(200); 
 if((estadoAtual==0) && (estadoAnterior!=estadoAtual)){ 
 estadoAnterior=estadoAtual; 
 estadoLed=!estadoLed; 
 digitalWrite(ledVerde, estadoLed); 
 } 
 if(estadoAtual==1){ 
 estadoAnterior=1; 
 } 
} 
Todo o segredo está nessa condicional (estadoAnterior!=estadoAtual) 
onde só permite entrar na conficional if((estadoAtual==0) && 
(estadoAnterior!=estadoAtual)) se o botão for pressionado porém se o 
estado anterior do botão for diferente do estado atual, ou seja, o botão 
precisa ser solto pra voltar a receber o valor 1 e entrar na condição que 
irá reiniciar o ciclo: 
 if(estadoAtual==1){ 
 estadoAnterior=1; 
 } 
Quando isso acontece, o estadoAnterior assume o valor de 1 e quando o 
botão for pressionado o estadoAenterior será diferente da variável 
estadoAtual que assume o valor zero por ser pressionado o botão, 
simples não é, mas ainda podemos deixar nosso código mais bonito, 
vamos conferir no próximo tópico. 
 
o Mudando o status do LED com um Botão - Função millis() 
Vamos avançar mais um nível em nossa programação, observe que nas 
programações anteriores, para evitar que a frequência gerada no botão 
no momento do toque seja interpretada pelo Arduino como múltiplos 
toques, usamos o delay que é uma função que faz o programa aguardar 
um tempo, ou seja, seu código literalmente para naquela linha, já 
imaginou se tivéssemos 10 botões e todos eu tivesse que fazer aguardar 
200 milissegundos para filtrar o debounce gerado no botão? Iria ter um 
atraso de 2 segundo em meu código, isso para muitos processos de 
sistemas embarcados seria um desastre, pois por exemplo, se o projeto 
fosse um carro não tripulado, se seu código parar por 2 segundos, seu 
carro poderia atropelar uma pessoas ou bater em algo, pois os demais 
sensores não estariam funcionando enquanto o código estivesse parado 
no delay. 
Para resolver isso iremos aprender a programar o botão usando a função 
millis(), onde ela surte o mesmo efeito em questão de benefício do delay, 
porém não para meu código. 
O millis é um contador interno do Arduino que inicia sua contagem assim 
que o liga ou reseta, através do millis é que determinamos todas as 
funções e ações que envolvem tempo. 
Vamos aproveitar a mesma montagem do tópico anterior, usando um 
botão, um led, um resistor, protoboard, fios jumper e um Arduino UNO. 
O código será o apresentado logo abaixo: 
 
/* 
 * Desenvolvedor: Sandro Mesquita 
 * Data: 23/01/2020 
 * Projeto: Ligando LED com Botão usando millis 
 * Publicado: Livro 
 */ 
int botao=9, ledVerde=8, debounce; 
unsigned long tempoInicial, tempoAtual; 
bool estadoLed=0, estadoAnterior=1; 
 
void setup() { 
 pinMode(ledVerde, OUTPUT); 
 pinMode(botao, INPUT_PULLUP); 
 tempoInicial=millis(); 
} 
 
void loop() { 
 int estadoAtual=digitalRead(botao); 
 
 tempoAtual = millis(); 
 debounce = tempoAtual - tempoInicial; 
 
 if((debounce>200) && (estadoAtual==0) && 
(estadoAnterior!=estadoAtual)){tempoInicial = millis(); 
 estadoAnterior=estadoAtual; 
 estadoLed=!estadoLed; 
 digitalWrite(ledVerde, estadoLed); 
 } 
 
 if(estadoAtual==1){ 
 estadoAnterior=1; 
 } 
 
} 
O que tem de novo neste código? Vamos começar pela declaração das 
variáveis: 
unsigned long tempoInicial, tempoAtual; 
Foi escolhido este tipo de variável por ela armazenar números longos, até 
4.294.967.295, como a função millis é um incrementador de tempo a cada 
1 milisegundo e ela não para de contar, eu preciso de um tipo de variável 
que possa armazenar o maior valor possível para meu Arduino continuar 
contando sem estourar essa pilha, por exemplo, como a capacidade do 
tipo unsigned long é de 4 bilhões 294 milhões 967 mil e 295 milisegundos, 
este tempo convertido em dias seria: 
4.294.967.295 / 1000 = 4.294.967,295 segundos 
4.294.967,295 / 60 = 71.528,79 minutos 
71.528,79 / 60 = 1.193,05 horas 
1.193,05 / 24 = 49,71 dias 
Ou seja, seu arduino tem a capacidade de contar carregando o millis na 
variável por até 49 dias sem estourar seu limite 
 
Dentro do setup instruo meu programa a armazenar o valor do milis logo 
assim que for iniciado, assim teremos uma referência inicial: 
tempoInicial=millis(); 
 
No loop, após a leitura do estado do botão, no lugar do delay, escrevemos 
as linhas abaixo: 
tempoAtual = millis(); 
debounce = tempoAtual - tempoInicial; 
Na primeira linha carrego de novo o valor do millis agora em uma variável 
que declaramos como tempoAtual, pois como eu já tenho salvo o tempo 
inicial, iremos fazer a subtração das duas variáveis, o tempoAtual menos 
o tempo Inicial, assim o resultado será a variável que definimos como 
debounce, ou seja, o tempo que desejo esperar para executar alguma 
ação, a diferença para o delay é que o código não para no debounce, ele 
carrega o tempo Atual, subtrai com o inicial e se for o valor programado 
entra na condicional, caso contrário vai percorrer todo o código 
novamente retornando para o inicio do loop de novo, carregando de novo 
um novo valor millis na variável tempoAtual, subtraindo com o tempo 
Inicial e testando se essa diferença é o valor programado de tempo que 
preciso, esse teste é feito na próxima linha, na condicional if. 
 
if((debounce>200) && (estadoAtual==0) && 
(estadoAnterior!=estadoAtual)){ 
 empoInicial = millis();t 
 estadoAnterior=estadoAtual; 
 estadoLed=!estadoLed; 
 digitalWrite(ledVerde, estadoLed); 
 } 
A cada passagem pelo início do loop o programa irá carregar o valor Atual 
do tempo millis, diminuir com o tempo inicial e testar se é maior que 200 
milissegundos, caso seja verdadeiro irá finalmente entrar na condicional 
if e executar nossa ação que seria ligar ou desligar o led, porém dentro 
desta condicional preciso recarregar de novo o valor no do millis na 
variável tempoInicial, para reiniciar todo o ciclo zerando o debounce: 
tempoInicial = millis(); 
 
Fácil não é? Agora vamos sair da leitura digital da porta e partir para a 
leitura analógica, vamos ler um valor de um potenciômetro na porta 
analógica do Arduino, esse é um assunto para o próximo tópico. 
 
o Mudando o status do LED com um Potenciômetro - Função 
analogwrite() 
O objetivo deste tópico é aprendermos a função map() usada no Arduino 
para conversão de valores, ela faz parte das funções matemáticas do 
Arduino. Lembra da regra de 3 que aprendemos no nosso ensino médio? 
Pois bem, a função map() faz exatamente esta continha. 
A função map() re-mapeia um número de um intervalo para outro, como 
uma escala em desenho técnico, onde para tal valor real é desenhado no 
papel um valor proporcional, vamos explicar melhor com outro exemplo. 
Se eu tenho uma distância para percorrer de 100 Km e só tenho 20 litros 
de gasolina na moto, que por coincidência é justamente o valor gasto para 
efetuar este deslocamento. Logo, quando eu estiver no quilômetro 50 de 
minha estrada eu terei consumido quantos litros de gasolina? 
Se você estivesse na aula de matemática, você iria fazer uma regra de 3, 
aqui, em nosso livro, você irá usar a função map() que fará essa regra por 
nós, veja como é a sintaxe desta função: 
map (valor, fromLow, fromHigh, toLow, toHigh); 
Então aplicando nosso exemplo nesta sintaxe, o comando ficaria assim: 
map (quilometro, 0, 100, 0, 20); 
O resultado desta conta pode ser armazenado em uma variável que você 
irá declarar em seu código: 
litros = map (quilometro, 0, 100, 0, 20); 
Logo, para um determinado quilômetro percorrido minha função irá me 
retornar uma quantidade de litros consumido. 
Vamos agora fazer uma prática com um potenciômetro e um LED, 
monte o circuito igual ao esquema da imagem abaixo: 
 
Ele deve ficar semelhante a foto em seguida: 
 
 
 
Agora escreva o código de acordo com o Sketch apresentado nas 
próximas linhas, observe que o mesmo está todo comentando 
dispensando explicação fora do código. 
/* 
 * Desenvolvedor: Sandro Mesquita 
 * Data: 31/01/2020 
 * Projeto: Alterando o Brilho do LED com Potenciometro 
 * Objetivo: 
 * - Aprender Leitura Analógica 
 * - Aprender escrita Analógica 
 * - Aprender função MAP 
 * Publicado: Livro 
 */ 
 #define pot A0 
 #define led 3 
 int valorPot, valorLed; 
 
void setup() { 
 pinMode(pot, INPUT);//Desnecessário 
 //As portas do Arduino já são de entrada por padrão 
 pinMode(led, OUTPUT); 
} 
 
void loop() { 
 valorPot = analogRead(pot); 
 //A leitura varia entre 0 e 1023 
 //O led esta ligado na PWM 
 //Para variar analogicamente 
 //A PWM varia de 0 a 255 
 //Logo precisa converter o valor lido em proporção 
 valorLed = map(valorPot, 0, 1023, 0, 255); 
 //Convertendo para valor máximo do led 
 analogWrite(led, valorLed); 
 //Envia para a porta do LED a tensão proporcional 
} 
 
A intensidade do brilho do LED irá mudar de acordo com o valor lido pelo 
Arduino do Potenciômetro, ou seja, quando você altera o valor do 
potenciômetro o girando para esquerda ou direita, a intensidade do brilho 
do LED também irá alterar proporcionalmente.