Práticas de microcontroladores e microprocessadores

Prévia do material em texto

Indaial – 2021
Práticas de 
Microcontroladores 
e MicroProcessadores
Prof.a Leyla Kraulich
Prof.a Rafaela Filomena Alves Guimarães
1a Edição
Copyright © UNIASSELVI 2021
Elaboração:
Prof.a Leyla Kraulich
Prof.a Rafaela Filomena Alves Guimarães
Revisão, Diagramação e Produção:
Centro Universitário Leonardo da Vinci – UNIASSELVI
Ficha catalográfica elaborada na fonte pela Biblioteca Dante Alighieri 
UNIASSELVI – Indaial.
Impresso por:
K91p
Kraulich, Leyla
Práticas de microcontroladores e microprocessadores. / Leyla 
Kraulich; Rafaela Filomena Alves Guimarães. – Indaial: UNIASSELVI, 2021.
265 p.; il.
ISBN 978-65-5663-907-9
ISBN Digital 978-65-5663-908-6
1. Microcontroladores. - Brasil. I. Guimarães, Rafaela Filomena Alves. 
II. Centro Universitário Leonardo da Vinci.
CDD 004
aPresentação
Olá, acadêmico! Seja bem-vindo ao Livro Didático da disciplina de 
Práticas de Microcontroladores e Microprocessadores. Tais componentes 
estão presentes em praticamente todos os dispositivos eletrônicos que nos 
cercam, como máquinas e dispositivos industriais, veículos, brinquedos, 
eletrodomésticos. Há uma grande variedade de microcontroladores 
disponíveis no mercado, porém o Arduíno é uma ótima opção de didática 
para aumentarmos nossa compreensão sobre o assunto, além de ser 
facilmente incorporado em nossos projetos.
Os microcontroladores e os componentes eletrônicos são o hardware, 
que darão forma ao seu projeto, enquanto o software, os códigos de 
programação escritos por você, serão processados pelo hardware e permitirão 
que os sensores e atuadores executem suas funções. Para que todas as etapas 
fiquem claras, subdividimos esta apostila em três unidades. 
Na Unidade 1, estudaremos os conceitos básicos sobre 
microcontroladores e introduzir nossos conhecimentos com relação ao seu 
hardware e software, principalmente sobre seu ambiente de desenvolvimento. 
Em seguida, na Unidade 2, começaremos a fazer projetos, utilizando 
o Arduíno UNO. Estes serão trabalhados conforme a ordem de complexidade 
dos algoritmos. Estudaremos o funcionamento dos dispositivos como matriz 
de contatos, resistores e outros eletrônicos, por uma abordagem mais prática 
para, posteriormente, trabalharmos uma sequência de projetos e desafios 
que abordam saídas analógicas e digitais, sensores e atuadores.
Por fim, na Unidade 3, aprenderemos daremos sequência a outros 
projetos práticos, utilizando sensores de pressão, temperatura, umidade; são 
projetos com motores, transistores displays e transistores.
Boa leitura e bons estudos!
Prof.a Leyla Kraulich
Prof.a Rafaela Filomena Alves Guimarães
Você já me conhece das outras disciplinas? Não? É calouro? Enfim, tanto para 
você que está chegando agora à UNIASSELVI quanto para você que já é veterano, há 
novidades em nosso material.
Na Educação a Distância, o livro impresso, entregue a todos os acadêmicos desde 2005, é 
o material base da disciplina. A partir de 2017, nossos livros estão de visual novo, com um 
formato mais prático, que cabe na bolsa e facilita a leitura. 
O conteúdo continua na íntegra, mas a estrutura interna foi aperfeiçoada com nova 
diagramação no texto, aproveitando ao máximo o espaço da página, o que também 
contribui para diminuir a extração de árvores para produção de folhas de papel, por exemplo.
Assim, a UNIASSELVI, preocupando-se com o impacto de nossas ações sobre o ambiente, 
apresenta também este livro no formato digital. Assim, você, acadêmico, tem a possibilidade 
de estudá-lo com versatilidade nas telas do celular, tablet ou computador. 
 
Eu mesmo, UNI, ganhei um novo layout, você me verá frequentemente e surgirei para 
apresentar dicas de vídeos e outras fontes de conhecimento que complementam o assunto 
em questão. 
Todos esses ajustes foram pensados a partir de relatos que recebemos nas pesquisas 
institucionais sobre os materiais impressos, para que você, nossa maior prioridade, possa 
continuar seus estudos com um material de qualidade.
Aproveito o momento para convidá-lo para um bate-papo sobre o Exame Nacional de 
Desempenho de Estudantes – ENADE. 
 
Bons estudos!
NOTA
Olá, acadêmico! Iniciamos agora mais uma disciplina e com ela 
um novo conhecimento. 
Com o objetivo de enriquecer seu conhecimento, construímos, além do livro 
que está em suas mãos, uma rica trilha de aprendizagem, por meio dela você terá 
contato com o vídeo da disciplina, o objeto de aprendizagem, materiais complementares, 
entre outros, todos pensados e construídos na intenção de auxiliar seu crescimento.
Acesse o QR Code, que levará ao AVA, e veja as novidades que preparamos para seu estudo.
Conte conosco, estaremos juntos nesta caminhada!
LEMBRETE
suMário
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO ................................ 1
TÓPICO 1 — MICROCONTROLADORES ...................................................................................... 3
1 INTRODUÇÃO .................................................................................................................................... 3
2 O QUE SÃO MICROCONTROLADORES .................................................................................... 3
3 APLICAÇÕES DOS MICROCONTROLADORES ...................................................................... 7
4 O MICROCONTROLADOR USADO NO ARDUÍNO ................................................................ 8
5 AS ORIGENS DO ARDUÍNO E SEUS MODELOS ..................................................................... 9
RESUMO DO TÓPICO 1..................................................................................................................... 13
AUTOATIVIDADE .............................................................................................................................. 14
TÓPICO 2 — ARDUÍNO: HARDWARE E SOFTWARE ............................................................... 17
1 INTRODUÇÃO .................................................................................................................................. 17
2 A PLACA DO ARDUÍNO UNO ..................................................................................................... 17
2.1 SHIELDS OU MÓDULOS ........................................................................................................... 18
3 ENTRADAS E SAÍDAS ANALÓGICAS E DIGITAIS ............................................................... 19
4 O AMBIENTE DE DESENVOLVIMENTO DO ARDUÍNO ..................................................... 21
RESUMO DO TÓPICO 2..................................................................................................................... 26
AUTOATIVIDADE .............................................................................................................................. 27
TÓPICO 3 — PROGRAMAÇÃO DO ARDUÍNO .......................................................................... 29
1 INTRODUÇÃO .................................................................................................................................. 29
2 ESTRUTURA BÁSICA E SINTAXE DO SKETCH ...................................................................... 30
3 CONSTANTES E VARIÁVEIS ........................................................................................................ 32
3.1 TIPOS DE DADOS ........................................................................................................................ 33
4 OPERADORES ARITMÉTICOS, RELACIONAIS, LÓGICOS ................................................ 35
5 ESTRUTURAS DE CONTROLE .................................................................................................... 37
5.1 SENTENÇA IF ............................................................................................................................... 37
5.2 SENTENÇA IF...ELSE................................................................................................................... 38
5.3 SENTENÇA IF...ELSE ANINHADAS ........................................................................................38
5.4 SENTENÇA SWITCH: CONDIÇÕES MÚLTIPLAS ................................................................. 39
6 ESTRUTURAS DE CONTROLE: LAÇOS .................................................................................... 40
6.1 SENTENÇA WHILE...................................................................................................................... 40
6.2 SENTENÇA DO...WHILE ............................................................................................................ 41
6.3 SENTENÇA FOR .......................................................................................................................... 41
7 FUNÇÕES ............................................................................................................................................ 42
8 BIBLIOTECAS .................................................................................................................................... 44
9 MONITOR SERIAL ........................................................................................................................... 46
LEITURA COMPLEMENTAR ............................................................................................................ 49
RESUMO DO TÓPICO 3..................................................................................................................... 52
AUTOATIVIDADE .............................................................................................................................. 53
REFERÊNCIAS ...................................................................................................................................... 55
UNIDADE 2 — PROJETOS PRÁTICOS PARA O ARDUINO – PARTE 1 ................................ 57
TÓPICO 1 — ENTRADAS E SAÍDAS .............................................................................................. 59
1 INTRODUÇÃO .................................................................................................................................. 59
2 ENTRADA E SAÍDA DIGITAL ...................................................................................................... 60
3 SAÍDA PWM ....................................................................................................................................... 62
4 ENTRADA ANALÓGICA ................................................................................................................ 63
RESUMO DO TÓPICO 1..................................................................................................................... 65
AUTOATIVIDADE .............................................................................................................................. 66
TÓPICO 2 — PROJETOS COM LED ................................................................................................ 69
1 INTRODUÇÃO .................................................................................................................................. 69
2 MONTAGEM DO CIRCUITO DO PROJETO N. 1 – PROJETO SIMPLES COM LED ....... 77
2.1 CÓDIGO DE PROGRAMAÇÃO DO PROJETO N. 1 .............................................................. 81
2.2 ESTUDANDO UM POUCO DO CÓDIGO DO PROJETO N. 1 ............................................. 86
3 CÓDIGO DE PROGRAMAÇÃO DO PROJETO N. 2 ................................................................ 87
3.1 ESTUDANDO UM POUCO DO CÓDIGO DO PROJETO N. 2 ............................................. 88
4 MONTAGEM DO CIRCUITO DO PROJETO n. 3 – PROJETO COM SEMÁFOROS ........ 89
4.1 CÓDIGO DE PROGRAMAÇÃO DO PROJETO N. 3 .............................................................. 92
4.2 ESTUDANDO UM POUCO DO CÓDIGO DO PROJETO N. 3 ............................................. 93
5 MONTAGEM DO CIRCUITO DO PROJETO N. 4 – PROJETO COM SEMÁFORO 
INTERATIVOS ................................................................................................................................... 93
5.1 CÓDIGO DE PROGRAMAÇÃO DO PROJETO N. 4 .............................................................. 98
5.2 ESTUDANDO UM POUCO DO CÓDIGO DO PROJETO N. 4 ........................................... 100
RESUMO DO TÓPICO 2................................................................................................................... 101
AUTOATIVIDADE ............................................................................................................................ 102
TÓPICO 3 — PROJETOS COM SONORIZADORES ................................................................. 105
1 INTRODUÇÃO ................................................................................................................................ 105
2 MONTAGEM DO CIRCUITO DO PROJETO n. 5 – PROJETOS COM 
SONORIZADOR PIEZO ................................................................................................................ 106
2.1 CÓDIGO DE PROGRAMAÇÃO DO PROJETO N. 5 ............................................................ 108
2.2 ESTUDANDO UM POUCO DO CÓDIGO DO PROJETO N. 5 ........................................... 109
3 MONTAGEM DO CIRCUITO DO PROJETO N. 6 – CONTROLANDO 
SONORIZADORES COM POTENCIÔMETRO ....................................................................... 110
3.1 CÓDIGO DE PROGRAMAÇÃO DO PROJETO N. 6 ............................................................ 115
4 MONTAGEM DO CIRCUITO DO PROJETO N. 7 – CONTROLANDO 
SONORIZADORES COM POTENCIÔMETRO E PWM ........................................................ 118
4.1 CÓDIGO DE PROGRAMAÇÃO DO PROJETO N. 7 ............................................................ 120
RESUMO DO TÓPICO 3................................................................................................................... 122
AUTOATIVIDADE ............................................................................................................................ 123
TÓPICO 4 — PROJETOS COM DISPLAYS .................................................................................. 125
1 INTRODUÇÃO ................................................................................................................................ 125
2 MONTAGEM DO CIRCUITO DO PROJETO N. 8 – PROJETOS COM DISPLAY ............ 126
2.2 CÓDIGO DE PROGRAMAÇÃO DO PROJETO N. 8 ............................................................ 133
3 DISPLAY DE LED DE 8 SEGMENTOS ........................................................................................ 136
4 DISPLAY DE CRISTAL LÍQUIDO (LCD) ................................................................................... 140
LEITURA COMPLEMENTAR .......................................................................................................... 149
RESUMO DO TÓPICO 4................................................................................................................... 159
AUTOATIVIDADE ............................................................................................................................ 160
REFERÊNCIAS .................................................................................................................................... 162
UNIDADE 3 — PROJETOS PRÁTICOS PARA O ARDUINO – PARTE 2 .............................. 163
TÓPICO 1 — SENSORES DE TEMPERATURA – PROJETO N. 1 ............................................ 165
1 INTRODUÇÃO ................................................................................................................................ 165
2 MONTAGEM DO CIRCUITO DO PROJETO N. 1 – SENSOR DE TEMPERATURA....... 167
3 CÓDIGO DE PROGRAMAÇÃO DO PROJETO N. 1 .............................................................. 177
RESUMO DO TÓPICO 1................................................................................................................... 183
AUTOATIVIDADE ............................................................................................................................ 184
TÓPICO 2 — SENSORES DE PRESSÃO– PROJETO N. 2 ........................................................ 189
1 INTRODUÇÃO ................................................................................................................................ 189
2 MONTAGEM DO CIRCUITO DO PROJETO N. 2 .................................................................. 190
3 CÓDIGO DE PROGRAMAÇÃO .................................................................................................. 191
RESUMO DO TÓPICO 2................................................................................................................... 196
AUTOATIVIDADE ............................................................................................................................ 197
TÓPICO 3 — SENSORES DE TEMPERATURA E UMIDADE – PROJETO N. 3 .................. 201
1 INTRODUÇÃO ................................................................................................................................ 201
2 MONTAGEM DO CIRCUITO ...................................................................................................... 201
3 CÓDIGO DE PROGRAMAÇÃO .................................................................................................. 205
4 ESTUDANDO OS CÓDIGOS ...................................................................................................... 208
RESUMO DO TÓPICO 3................................................................................................................... 209
AUTOATIVIDADE ............................................................................................................................ 210
TÓPICO 4 — CONTROLE DE UM MOTOR SIMPLES – PROJETO N. 4 .............................. 213
1 INTRODUÇÃO ................................................................................................................................ 213
2 PROJETO N. 4 ................................................................................................................................... 213
3 MONTAGEM DO CIRCUITO ...................................................................................................... 215
4 CÓDIGO DE PROGRAMAÇÃO .................................................................................................. 221
5 ESTUDANDO OS CÓDIGOS ...................................................................................................... 224
6 CONTROLE DE MOTORES COM TRANSISTOR – PROJETO N. 5 ................................... 224
7 MONTAGEM DO CIRCUITO ...................................................................................................... 226
8 CÓDIGO DE PROGRAMAÇÃO .................................................................................................. 234
RESUMO DO TÓPICO 4................................................................................................................... 237
AUTOATIVIDADE ............................................................................................................................ 238
TÓPICO 5 — OUTROS PROJETOS................................................................................................ 241
1 INTRODUÇÃO ................................................................................................................................ 241
2 CONTROLE DE SERVOMECANISMOS – PROJETOS N. 6 E 7 ........................................... 241
3 MONTAGEM DO CIRCUITO DO PROJETO N. 6 .................................................................. 243
4 CÓDIGO DE PROGRAMAÇÃO DO PROJETO N. 6 .............................................................. 246
5 ESTUDANDO UM POUCO DO CÓDIGO DO PROJETO N. 7 ............................................ 247
6 MONTAGEM DO PROJETO N. 07 – CONTROLE DE DOIS SERVOMOTORES 
(UM ESQUERDO E UM DIREITO) ............................................................................................ 250
7 CÓDIGO DE PROGRAMAÇÃO DO PROJETO N. 7 .............................................................. 252
LEITURA COMPLEMENTAR .......................................................................................................... 255
RESUMO DO TÓPICO 5................................................................................................................... 262
AUTOATIVIDADE ............................................................................................................................ 263
REFERÊNCIAS .................................................................................................................................... 265
1
UNIDADE 1 — 
INTRODUÇÃO À PLATAFORMA DO 
ARDUÍNO UNO
OBJETIVOS DE APRENDIZAGEM
PLANO DE ESTUDOS
A partir do estudo desta unidade, você deverá ser capaz de: 
• entender o que são microcontroladores;
• conhecer as aplicações dos microcontroladores;
• saber sobre o funcionamento do Arduíno e entender suas principais 
vantagens em relação a outras plataformas de desenvolvimento de 
microcontroladores e a facilidade de sua utilização;
• reconhecer seus principais componentes, as entradas e saídas e seu 
hardware;
• entender os fundamentos básicos da programação utilizada no Arduíno.
Esta unidade está dividida em três tópicos. No decorrer da unidade, 
você encontrará autoatividades com o objetivo de reforçar o conteúdo 
apresentado.
TÓPICO 1 – MICROCONTROLADORES
TÓPICO 2 – INTRODUÇÃO AO ARDUÍNO
TÓPICO 3 – PROGRAMAÇÃO DO ARDUÍNO
Preparado para ampliar seus conhecimentos? Respire e vamos 
em frente! Procure um ambiente que facilite a concentração, assim absorverá 
melhor as informações.
CHAMADA
2
3
TÓPICO 1 — 
UNIDADE 1
MICROCONTROLADORES
1 INTRODUÇÃO
Os microcontroladores cumprem um papel fundamental no nosso 
cotidiano, estão presentes em equipamentos eletroeletrônicos, impressoras, 
brinquedos, circuitos de automóveis e todos os aparelhos que necessitam 
de automação e controle. De certa forma, essa automatização das máquinas 
proporcionou desenvolver tarefas com maior agilidade, além de substituir a mão 
de obra braçal, por vezes até insalubres e perigosas.
O mercado de microcontroladores oferece várias opções de fabricantes, 
assim como diferentes dispositivos, diferenciados basicamente por sua arquitetura 
e capacidade de processamento. O dispositivo precisa ser programado, ou 
seja, o projetista deve escrever um programa que contenha o processamento a 
ser executado. A linguagem usada para escrever tais algoritmos pode variar de 
acordo com o microcontrolador escolhido.
Iniciaremos nosso estudo sobre microcontroladores, em especial o Arduíno 
UNO. Para tanto, é imprescindível entendermos o que são os microcontroladores, 
o que é o Arduíno, quais são as configurações e versões de placas ofertadas no 
mercado. Na sequência, em outras unidades do estudo, vamos manipular seu 
software e colocar em prática seus experimentos.
2 O QUE SÃO MICROCONTROLADORES 
Tanto os microcontroladores como os microprocessadores precisam 
de um programa (software) para indicar as tarefas a serem executadas. 
Essas instruções são gravadas na memória de programa que, no caso do 
microcontrolador, fica em uma parte da memória EEPROM interna, e nos 
microprocessadores fica em uma memória não volátil externa ao chip. 
Esse programa é executado pela UC (Unidade de Controle), que lê essas 
instruções na sequência, executa cálculos e comparações na ULA (Unidade 
Lógica e Aritmética) e utiliza a memória RAM para armazenar os resultados e 
para poder consultá-los de acordo com a necessidade do programa.
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
4
Entre os anos de 1998 e 2000, tínhamos à disposição basicamente 
duas famílias de microcontroladores: a família 8051 da INTEL e a família 
PIC da Microchip. Nessa época, era muito trabalhoso criarmos projetos com 
microcontroladores, até mesmo pela falta de opções e acesso a informações.
Os códigos de programação necessitavam de mainframes para processar as 
informações. Não existiam ferramentas de busca como Google e tampouco acesso 
à internet.Todas essas questões dificultavam a programação. Na década de 1970, o 
microcontrolador foi inventado pela Texas Instruments e, mais ou menos na mesma 
época, o microprocessador foi inventado pela Intel.
Um dos grandes fabricantes mundiais de microcontroladores é a Microchip, 
responsável por produzir os microcontroladores PIC (Peripherical Interface 
Controller). E, originalmente, os sistemas embarcados eram desenvolvidos em 
Assembly, em uma linguagem de baixo nível, eficiente em termos de velocidade 
e uso de memória, porém que exige mais tempo para desenvolvimento, devido à 
necessidade de conhecimento de arquitetura do controlador. Com essa linguagem, 
era necessário trabalhar byte a byte e, às vezes, bit a bit. 
 Um software chamado compilador convertia esses códigos em linguagem 
de máquina, fornecendo um arquivo hexadecimal com extensão hex. Um pouco 
mais tarde, surgiram os tradutores que permitiam a construção do seu software 
em linguagem C, bem mais amigável aos olhos humanos, e que convertia os 
comandos para códigos hexadecimais no compilador.
A Microchip teve domínio do mercado até o lançamento da ATMEL, 
com a família AVR, e está cada vez mais popular com a plataforma Arduíno. 
Segundo Germiniani (2013), a ATMEL fez bastante sucesso também com os 
microcontroladores CORE M0+ e M4, além dos processadores ARM A5 para 
aplicações de alta performance. Essa sequência de sucessos talvez tenha motivado 
uma ação até então inusitada: no início de 2016, a Microchip adquiriu a Atmel.
Com o projeto Arduíno, as práticas de microcontroladores tornaram 
a programação muito flexível. Afinal, a ATMEL disponibiliza em seu site 
documentação que ajuda na resolução de problemas. O AVR segue a arquitetura 
de Harvard, em que os barramentos associados às memórias de dados e do 
programa são distintos.
A grande oferta de placas de Arduíno facilita a conexão com outros 
dispositivos, e sua IDE é extremamente amigável, permitindo a utilização por 
designers e admiradores do mundo inteiro, aumentando a demanda de sensores 
e outros periféricos eletrônicos, barateando esses dispositivos.
Um microcontrolador é uma placa de circuito que incorpora no mesmo 
encapsulamento o microprocessador, a memória de programa e a memória de 
dados. Além disso, possui uma série de pinos com entradas e saídas e vários 
periféricos, resultando em um hardware final complexo. Normalmente, a 
diferença entre essas características é o que diferencia os microcontroladores.
TÓPICO 1 — MICROCONTROLADORES
5
Já o microprocessador, é um chip programável, que não pode atuar 
sozinho, é necessário associar a ele uma unidade de memória RAM, uma de 
memória ROM e registradores de deslocamentos externos (que nada mais são do 
que chips com funções de entrada e saída). A conexão entre esses componentes 
é feita através de uma Placa Mãe. Quando todo esse conjunto englobado pela 
Placa Mãe é colocado dentro de um único Circuito Integrado (CI), obtemos um 
microcontrolador.
 Na Figura 1, podemos observar em (a) um exemplo de microprocessador, 
em (b) (c) e (d) exemplos de microcontroladores.
FIGURA 1 – TIPOS DE MICROCONTROLADORES
FONTE: <https://blog.multcomercial.com.br/microcontrolador-saiba-o-que-e-e-como-usar/>. 
Acesso em: 15 jul. 2021.
Podemos fazer uma analogia de um microprocessador com uma CPU de 
um computador. Ele contém a unidade de controle, a unidade lógica e aritméticas 
e registradores (acumuladores). Formado por com milhões de transistores 
em conjunto para armazenamento e manipulação de dados, ele compõe os 
computadores, sendo uma das suas peças internas. Já o microcontrolador (MCU) é 
um processador especial, geralmente contém no mesmo chip diversos periféricos, 
sendo usado na maior parte das vezes como controle digital (MONTEIRO, 2018).
Microcontroladores são produzidos basicamente a partir de dispositivos 
semicondutores de dimensões micrométricas, daí deriva seu prefixo “micro”. O 
objetivo de seus fabricantes é reduzir a cada dia, as dimensões destes dispositivos, 
visto que há um grande avanço na nanoeletrônica.
Os custos dos microcontroladores possuem um custo reduzido por serem 
produzidos em larga escala. Dentro os principais fabricantes temos: Motorola, 
Microchip, ATMEL, Intel, Mitsubishi, NEC, Philips, SGS, Hitachi e Toshiba. 
Dispositivos compostos dentro por um único chip, memória (de dados 
e de programa), entrada/saída, temporizadores, relógio interno, entre outros 
hardwares específicos. Esses dispositivos de controle possuem baixo preço e alta 
eficiência, além de outras funções diferenciadas, normalmente não encontradas 
em microprocessadores excelentes (temporizadores, conversores A/D e D/A) 
(MONTEIRO, 2018).
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
6
De acordo com Germiniani (2020), possuem como principais características:
• são programados para executar uma única e determinada tarefa; a fim de 
alterar a sua funcionalidade, é necessária programá-lo com novo software;
• consome menos energia, dadas as suas características físicas serem menores e 
menos exigentes em termos energéticos do que um tradicional PC, computador 
portátil ou servidor. Os programadores de microcontroladores se focam em 
manter o consumo energético das suas aplicações baixo, para que aplicações 
portáteis que utilizem baterias possam funcionar durante mais tempo;
• entradas/saídas reconfiguráveis. Os microcontroladores possuem aquilo 
que chamamos periféricos, que permitem estabelecer conexões entre um 
microcontrolador e outros microcontroladores ou computadores (como USB, 
CAN, UART); permitem ter a percepção de processos no mundo físico e 
real (por exemplo, ações de comutação, medição de temperatura etc.) e nos 
permitem controlar esses processos (como em controle de motores, alertas de 
disparos etc.);
• programação de memória não-volátil (EEPROM, Flash), desse modo, o 
programa do controlador pode ser regravado várias vezes, inclusive podendo 
até mesmo se autogravar;
• possuem interrupções, sendo assim, algumas funções podem ser executadas 
quando acontece algo importante, suspendendo a operação em execução para 
que outras mais importantes possam ser executadas;
• possuem entradas e saídas (E/S) analógicas e digitais, permitindo a leitura e a 
saída de tensão na faixa de 0 a 5 volts corrente contínua;
• possui E/S serial, permitindo transmissão e recepção com outros dispositivos 
por meio da comunicação serial, obedecendo os protocolos de comunicação 
RS232, I2C e SPI. 
FIGURA 2 – COMPONENTES DE UM MICROCONTROLADOR
FONTE: <https://drive.google.com/file/d/10WDga0ETzuy_In4OY0C-8Y_jlvlyQ3gs/view>. 
Acesso em 15 jul. 2021.
TÓPICO 1 — MICROCONTROLADORES
7
A diferença entre microcontrolador e microprocessador é bastante 
simples, o microcontrolador, além da UCP, contém blocos internos de memória 
em um único chip. Entretanto, sua aplicação é para sistemas embarcados com 
função específica. Já o microprocessador precisa de componentes externos 
para seu devido funcionamento, sendo sua grande vantagem, seu poder de 
processamento. Com isso, ele é aplicado no uso de computadores, smartphones e 
sistemas de maior complexidade. 
3 APLICAÇÕES DOS MICROCONTROLADORES 
Podemos encontrar microcontroladores nas mais diversas áreas, quando 
é necessário manipular e armazenar altas quantidades de dados e para realizar 
simples tarefas de controle. 
Há um crescente investimento pelas companhias da indústria 
automobilística em microcontroladores, pois eles estão presentes até mesmo 
na produção de veículos. O avanço tecnológico não só permitiu o crescimento 
do processamento, como também acabou tornando o custo bem mais acessível, 
desde o uso pessoal até para as empresas.
Em veículos, esses componentes também nos ajudam em questão de 
conforto, segurança e eficiência. Um sistema eletrônico embarcado atua no 
controle de estabilidade, controle de tração, freios inteligentes, e executa funções 
específicas para oferecer conforto às necessidades dos usuários.
Nos eletrodomésticos percebemossua presença no cotidiano, em 
condicionadores de ar, máquinas de lavar, cafeteiras, geladeira, até mesmo em 
equipamentos de comunicação, cada vez mais presente em nossa sociedade, em 
equipamentos de rede como switch e roteador, telefones. Está presente todos os 
eletrodomésticos básicos, que facilitam, melhoram e otimizam a vida dos usuários.
Conforme Neto, Monteiro e Queiroga (2012, p. 5),
Na área da segurança, é comum o uso de sistemas microcontroladores, 
como alarmes residenciais, discadores, sensores perimétricos, trancas 
e fechaduras eletrônicas, portões motorizados, sensores de presença e 
de iluminação.
De modo geral, os microcontroladores são, atualmente, componentes 
tecnológicos que favorecem a vida moderna. Aumentam a eficiência, 
permitem a redução de custo e um significativo aumento de 
funcionalidades, facilitando e melhorando a vida dos usuários e 
agregando valor aos produtos onde são aplicados.
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
8
Microcontrolador é uma coisa, microprocessador é outra. São arquiteturas 
diferentes para propósitos diferentes. Um microcontrolador contém um microprocessador.
ATENCAO
4 O MICROCONTROLADOR USADO NO ARDUÍNO
O Arduíno é uma plataforma de hardware projetada sobre o 
microcontrolador AVR da fabricante ATMEL que possui capacidade de 8 bits e 32 
bits. Dentre seus benefícios e características, podemos citar a ótima eficiência de 
processamento e núcleo compacto. Possui arquitetura voltada à programação C, 
a qual permite produzir códigos compactos, além de existir microcontroladores 
AVR específicos para diversas áreas.
 Segundo Oki e Mantovani (2013, p. 6), as principais características dos 
microcontroladores AVR são:
• executam poderosas instruções em um simples ciclo de clock e 
operam com tensões entre 1,8 e 5,5 V, com velocidades de até 20 
MHz. Estão disponíveis em diversos encapsulamentos (de 8 até 64 
pinos);
• alta integração e grande número de periféricos com efetiva 
compatibilidade entre toda a família AVR;
• possuem vários modos para redução do consumo de energia;
• possuem 32 registradores de propósito geral, memória de acesso 
load-store e a maioria das instruções é de 16bits;
• memória de programação FLASH programável in-system, SRAM 
e EEPROM, para desenvolvimentos rápidos e flexibilidade de 
projeto;
• preço acessível e um conjunto completo e gratuito de softwares.
Para um melhor entendimento, é possível identificar os elementos 
principais do circuito por meio do diagrama em blocos.
TÓPICO 1 — MICROCONTROLADORES
9
FIGURA 3 – DIAGRAMA DE BLOCOS DO ARDUÍNO
FONTE: Monk (2010, p. 10)
O ATmega328 tem 32 KB de memória flash (em que é armazenado o 
software), além de 2 KB de SRAM (em que ficam as variáveis) e 1 KB de EEPROM 
(esta última pode ser lida e escrita por meio da biblioteca EEPROM e guarda os 
dados permanentemente, mesmo que desliguemos a placa). A memória SRAM é 
apagada toda vez que desligamos o circuito.
5 AS ORIGENS DO ARDUÍNO E SEUS MODELOS 
O Arduíno foi um projeto que teve início na Itália no ano de 2005, seus 
desenvolvedores são: Massimo Banzi, David Cuartielles, Tom Igoe, Gianlica 
Martino e David Mellis. O objetivo era elaborar um dispositivo que fosse ao barato, 
funcional e fácil de programar, acessível para que estudantes e projetistas amadores.
Uma particularidade desses dispositivos é que se trata de uma plataforma 
de hardware código aberto (open source). Essa expressão nos permite dizer que 
qualquer um com conhecimento em programação é livre para modificá-lo e 
ampliá-lo de acordo com a necessidade, visando sempre à melhoria dos produtos 
que possam ser criados a partir do Arduíno ou, ainda, está aberto para uso e 
contribuição de toda sociedade.
Mesmo sendo uma plataforma open source, este dispositivo possui sua 
marca registrada, por esse motivo outras placas similares construídas por outras 
pessoas não podem utilizar o nome Arduíno.
Com o decorrer dos anos, a linha Arduíno ampliou-se, buscando soluções 
para os mais diversos projetos. Conheça um pouco mais dessa família com as 
imagens da Figura 4, alguns modelos listados no site oficial do Arduíno. Cada tipo 
tem sua característica e vantagens específicas para projetos que se deseja realizar.
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
10
FIGURA 4 – TIPOS DE MICROCONTROLADORES
FONTE: <https://www.arduino.cc/en/Main/Products>. Acesso em 15 jul. 2021.
No Quadro 1, podemos observar as especificações de alguns modelos de 
placa, e que o modelo a ser escolhido depende da necessidade do seu projeto, por 
exemplo, em processos que requerem altas taxas de processamento, uma opção é 
o Arduíno Due, que é cerca de 15 vezes mais rápido comparado ao Arduíno Uno 
e possui duas portas DAC além das PWM normais. 
Além disso, ele tem um ADC de 12 bits em vez dos atuais 10 bits do Uno, 
mas infelizmente o custo é o dobro da plataforma Arduíno Uno. Tendo isso em 
vista, pode-se dizer que o Arduíno uno é uma opção barata para aplicações de 
desenvolvimento que não exijam tanta exatidão e confiabilidade, sendo ideal 
para iniciantes e na área educacional (GERMINIANI, 2021).
TÓPICO 1 — MICROCONTROLADORES
11
QUADRO 1 – MODELO DE QUADRO
FONTE: <https://www.filipeflop.com/blog/tipos-de-arduino-qual-comprar/>. 
Acesso em: 1° ago. 2021.
Considerando as características técnicas, de acordo com Germiniani 
(2021), temos 12 especificações que o desenvolvedor deve levar em conta na 
escolha de um microcontrolador para seu produto.
1- Memória – atualmente, os microcontroladores disponíveis no mercado 
já contam com memórias RAM e Flash em sua estrutura. A Flash é uma 
memória não-volátil utilizada para armazenamento de programa, já a RAM 
é uma memória volátil para armazenamento de dados temporários. Alguns 
microcontroladores também incluem a memória EEPROM, responsável pelo 
armazenamento de dados permanentes.
2- GPIOs (Digital General Purpose Input and Output) – são pinos utilizados 
para entrada e saída.
3- Entrada Analógica – a maioria dos microcontroladores possui a capacidade 
de ler de forma precisa tensões analógicas. Os sinais analógicos são vistos 
pelo microcontrolador por meio de um conversor analógico digital (ADC).
4- Saída Analógica – os sinais podem ser gerados pelo microcontrolador por 
meio de um conversor digital analógico (DAC) ou por um gerador de PWM, 
nem todos os microcontroladores possuem um DAC mas oferecem saídas 
PWM.
5- In Circuit Programming (ISP) – o ISP permite ao desenvolvedor programar o 
microcontrolador enquanto ele estiver instalado no circuito de aplicação, não 
existe a necessidade de removê-lo, apenas para gravá-lo. Os dois protocolos 
mais conhecidos são JTAG e SWD.
6- Wireless – se o seu produto necessita de interfaces sem fio, há 
microcontroladores especializados para esse tipo de aplicação que oferecem 
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
12
bluetooth, wifi, zigbee, entre outros padrões wireless.
7- Comunicação Serial – todos os microcontroladores oferecem algum tipo de 
comunicação serial. Os vários protocolos de comunicação serial são UART, 
SPI, I2C.
8- UART (Universal Asynchronous Receiver Transmitter) – é uma porta serial 
que transmite palavras digitais, tipicamente de comprimento de 7 a 8 bits, sua 
função é possibilitar a transmissão e a recepção de dados seriais.
9- SPI (Serial Peripheral Interface) – SPI é utilizado para comunicações seriais 
de curta distância entre microcontrolador e periféricos, SPI é um protocolo 
síncrono, ou seja, possui um clock que temporiza a comunicação, a SPI possui 
por padrão 4 sinais (data in, data out, clock e chip select).
10- I2C (Inter Integrated circuit) – é um barramento serial de 2 sinais, muito 
utilizado na comunicação entre o microcontrolador e outros chips da placa, 
assim como o SPI, o I2C é um protocolo síncrono. No entanto, o I2C possui 
um único sinal para data in e data out e, em vez de um pino de seleção de 
chip (Chip Select), o I2C utiliza um único endereço para cada periférico; essepadrão de comunicação possui como vantagem utilizar apenas 2 sinais, em 
que o padrão SPI utiliza 4 sinais, porém, o I2C é mais lento que o SPI.
11- USB (Universal Serial Bus) – é provavelmente o padrão mais familiar, USB 
é um dos protocolos de comunicação serial mais rápidos, é normalmente 
utilizado para ligação de periféricos que necessitam de grandes quantidades 
de transferência de dados.
12- CAN (Controller Area Network) – é um padrão de comunicação serial 
desenvolvido para ser utilizado apenas em aplicações automotivas.
Um fato muito importante com relação ao Arduíno é que há muito suporte 
disponível na rede, com vários fóruns e discussões e até mesmo a plataforma 
Arduíno, que favorece a interação com seus usuários.
As duas linguagens mais comuns para programação de microcontroladores 
são Assembly e C, e as principais diferenças entre ambas são:
• a linguagem C torna a programação amigável, facilitando a 
programação de aplicações mais complexas;
• a linguagem C aumenta a portabilidade, uma vez que as instruções 
Assembly variam muito até mesmo entre os mesmos fabricantes;
• a linguagem C permite o aproveitamento de código com uso de 
bibliotecas;
• é necessário controle do hardware para programar em Assembly;
• o tamanho do código em Assembly será sempre menor;
• os programas em Assembly tendem a ser mais rápidos (MONTEIRO, 
2018, p. 19-20).
13
Neste tópico, você aprendeu que: 
• O mercado de componentes eletrônicos oferece várias opções de fabricantes e 
diferentes dispositivos. Com relação a sua utilização, são fortemente usados 
em circuitos de automóveis, robótica, equipamentos biomédicos; de modo 
geral, todos aqueles que necessitam de automação e controle. 
• Microprocessadores e microcontroladores são componentes diferentes, e um 
microcontrolador contém um microprocessador, mas não o contrário.
• O Arduíno foi um projeto que teve início na Itália no ano de 2005 com o objetivo 
de ser um dispositivo barato, funcional e fácil de programar, acessível para 
estudantes e projetistas amadores.
• O Arduíno é uma plataforma de hardware projetada sobre o microcontrolador 
AVR da fabricante ATMEL, que possui capacidade de 8 bits e 32 bits. Apresenta 
uma ótima eficiência de processamento e núcleo compacto (milhares de portas 
lógicas). Possui arquitetura voltada à programação C, a qual permite produzir 
códigos compactos.
• O Arduíno é um embarcado e possui microcontrolador (tem sua própria 
memória e processador, sendo capaz de realizar qualquer instrução que for 
programada) ATMEGA. É uma plataforma Open-Source, mesmo assim possui 
sua marca registrada.
• É preciso observar especificações que o desenvolvedor deve levar em conta na 
escolha de um microcontrolador para seu projeto.
RESUMO DO TÓPICO 1
14
1 Microcontroladores estão cada vez mais presentes no nosso cotidiano, 
agregam conforto e facilidades que não tínhamos antes. Sobre esses 
componentes, assinale a alternativa CORRETA:
a) ( ) Para programar o Arduíno, é necessário que o projetista domine 
exatamente seu hardware.
b) ( ) Há apenas dois valores que um pino do Arduíno pode assumir: HIGH 
e LOW, e pode estar configurado como entrada ou saída.
c) ( ) Pinos que estão configurado como pinMode() OUTPUT estão na entrada 
e os que estão INPUT são os de saída.
d) ( ) Os microcontroladores da ATEMEL apresentam baixa eficiência e 
núcleo compacto.
2 O microcontrolador pode ser considerado como um computador em um 
único chip. Abaixo estão descritos alguns dispositivos que podem fazer 
parte de um microcontrolador. Sobre a composição do microcontrolador, 
analise as sentenças a seguir:
I- Possui barramentos de entrada e saída para se conectar a dispositivos 
externos, os quais colaboram para aumentar sua funcionalidade.
II- Normalmente a disposição interna de um microcontrolador divide-se em 
duas arquiteturas, Harvard e Yale.
III- O Arduíno é composto pelos microcontroladores AVR da fabricante 
ATMEL. 
IV- Internamente, o Arduíno possui uma variedade de osciladores, 
temporizadores, portas seriais, conversores A/D, que facilitam o trabalho 
para seus usuários.
Assinale a alternativa CORRETA:
a) ( ) As sentenças I e IV estão corretas.
b) ( ) As sentenças I e III estão corretas.
c) ( ) As sentenças II e III estão corretas.
d) ( ) As sentenças III e IV estão corretas.
3 O Arduíno surgiu na Itália em 2005, visando projetos de eletrônica e 
programação de forma interativa. Possui um conjunto de ferramentas 
acessíveis de baixo custo. Sobre esse dispositivo, assinale a alternativa é 
CORRETA:
a) ( ) Um microcontrolador pode conter apenas uma memória principal, 
onde estão armazenados os programas a serem manipulados pelo 
processador.
b) ( ) Para que o microprocessador se comunique com as memórias, não há 
necessidade de um sistema de controle.
AUTOATIVIDADE
15
c) ( ) Os microcontroladores contêm os microprocessadores, memórias de 
dados e uma infinidade de periféricos, como contadores, interfaces de 
entrada e saída.
d) ( ) Linguagens de programação podem ser instruções isoladas, e não 
há necessidade de ordenar instruções para que tenha eficiência no 
processo de execução.
4 As duas linguagens mais comuns para programação de microcontroladores 
são Assembly e C. Disserte sobre as principais diferenças entre ambas.
5 Um microcontrolador se diferencia de um microprocessador em 
vários aspectos. Disserte sobre as diferenças entre microcontrolador e 
microprocessador.
16
17
TÓPICO 2 — 
UNIDADE 1
ARDUÍNO: HARDWARE E SOFTWARE
1 INTRODUÇÃO
O Arduíno é uma plataforma embarcada, com grande versatilidade para 
protótipos eletrônicos, com vantagens de baixo custo e facilidade de utilização, 
mesmo para pessoas que possuem pouco conhecimento em eletrônica. Nos 
estudos, vamos usar como referência o Arduíno UNO, versão mais comercializada 
neste segmento. 
Neste tópico, estudaremos o funcionamento do seu hardware e o ambiente 
de desenvolvimento para execução de projetos. O Arduíno pode ler sensores, 
controlar atuadores (motor, lâmpadas) processar a informação, e assim, controlar 
dispositivos ou ambiente de acordo com as necessidades do usuário.
É importante lembrarmos que hardware é a placa que possui como 
componentes central um microcontrolador da família ATmega; software 
consiste na linguagem de programação e um ambiente de desenvolvimento 
derivados do Processing. Sua comunidade é composta de grande número 
de pessoas que compartilham os seus conhecimentos e projetos na internet, 
disseminando a plataforma.
2 A PLACA DO ARDUÍNO UNO 
Por meio da Figura 5, identificamos os itens que compõem seu hardware. 
A organização da placa é apresentada conforme os itens:
• microcontrolador ATmega328: cérebro da placa, ou seja, onde todo o 
processamento de dados é feito. Basicamente, uma CPU com clock de 20 MHz, 
8 bits e 32 kB de memória flash. É neste controlador que os programas são 
armazenados;
• porta USB: é onde ocorre a comunicação com o computador, também serve 
como fonte de alimentação da placa;
• fonte de alimentação: usada quando desejamos operar a placa sem um 
computador. Para adaptadores AC, recomenda-se uma tensão de 9 a 12 volts;
• 14 pinos de entrada e saída digital (pino 0 -13): são utilizados como entradas e 
saídas digitais de acordo com a necessidade do projeto, conforme foi definido 
no código;
18
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
• 6 pinos de entradas analógicas (pinos A0 – A5): esses pinos são dedicados a 
receber valores analógicos, por exemplo, a tensão de um sensor. O valor deve 
estar na faixa de 0 a 5V, que serão convertidos para valores entre 0 a 1023;
• 6 pinos de saídas analógicas (pinos 3, 5, 6, 9, 10 e 11): são pinos digitais 
que podem ser programados para serem utilizados como saídas analógicas, 
utilizando modulação PWM (ZANETTI, 2015);
• alguns possuem símbolo ∼, que representa uma saída do tipo PWM (Modulação 
por Largura de Pulso), que seria uma forma de simular uma saída analógica;
• LEDs TX e RX indicama comunicação entre o Arduíno e seu computador. Eles 
acendem quando há upload de código e durante a comunicação serial.
FIGURA 5 – PLACA DO ARDUÍNO UNO
FONTE: Kerschbaumer (2018, p. 54)
2.1 SHIELDS OU MÓDULOS
Uma característica relevante da plataforma Arduíno é a possibilidade de 
expansão por meio de extensões chamadas shields. Essas são placas de expansão 
que são plugadas ao Arduíno a fim proporcionar novas funcionalidades que 
sozinho ele não seria capaz. As shields podem ser utilizadas desde o controle 
de motores, até a comunicação sem fio, e ainda podem conter displays de LCD, 
sensores, módulos de comunicação ou relés, por exemplo.
Segundo McRoberts (2011), um exemplo de shield bastante utilizado em 
projetos é o Shield Ethernet, cuja função é permitir que a pessoa tenha acesso à rede 
(Ethernet ou Internet) por meio da conexão de um cabo entre o shield e o roteador. 
Na Figura 6, podemos observar uma imagem da Shield Ethernet. A capacidade de 
expansão possibilita uma infinidade de aplicações de maneira simples e rápida. 
TÓPICO 2 — ARDUÍNO: HARDWARE E SOFTWARE
19
FIGURA 6 – PLACA DO ARDUÍNO UNO E SHIELD ETHERNET
FONTE: <https://www.usinainfo.com.br/blog/Arduíno-vs-raspberry-pi-qual-a-diferenca/>.
 Acesso em: 15 jul. 2021.
O funcionamento das shields é completamente dependente do Arduíno 
e, na maior parte das vezes, necessita de bibliotecas de software específicas 
para funcionar corretamente. Essas bibliotecas devem ser instaladas no IDE do 
Arduíno, baixando-as do website do fabricante do shield, algumas inclusive estão 
presentes como bibliotecas padrão do Arduíno.
3 ENTRADAS E SAÍDAS ANALÓGICAS E DIGITAIS
Portas digitais têm seu funcionamento baseados em princípios booleanos, 
ou seja, apenas dois estados que podemos denominar de verdadeiro ou falso, 
certo ou errado, 0 ou 1, HIGH ou LOW. No caso do Arduíno, a nomenclatura mais 
utilizada é HIGH ou LOW. Estar HIGH será interpretado como está passando 
corrente elétrica por aquela porta, em contrapartida, o LOW significa que não 
está circulando corrente elétrica. Na Figura 7, temos um gráfico representativo 
dessa situação.
FIGURA 7 – REPRESENTAÇÃO DE HIGH E LOW
FONTE: As autoras
Isso significa que precisamos trabalhar com valores bem definidos de 
tensão quando utilizamos as portas digitais. Nesse caso, estamos trabalhando 
com valores digitais binários, ou seja, projetamos valores que utilizam apenas 
dois valores. No Arduíno, geralmente utilizamos as tensões 0 V e 5 V. 
20
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
Dessa forma, as portas digitais podem trabalhar com essas duas tensões, 
sendo que o software que desenvolveremos poderá requisitar ao microcontrolador 
que optamos por fornecer 0 V em uma determinada porta, ou ainda 5 V; e a 
resposta será lida em outra porta (que também terá uma resposta de 0 V ou 5 V).
Em portas analógicas, obviamente teremos uma possibilidade maior que 
duas (HIGH e LOW), pois sua resolução é de 10 bits, ou seja, de 0 a 1023. Isso 
significa que precisamos aplicar uma regra de três para fazer a conversão em 
volts. Por exemplo, se temos uma tensão de 3,5 V, então o Arduíno fornecerá o 
número 716.
Outro recurso é o Pulse Width Modulation, conhecido por PWM. Por meio 
dele, podemos controlar a potência do dispositivo. Se observarmos a placa de 
Arduíno, em geral esse recurso é posicionado próximo às portas digitais. Com 
ele podemos controlar a razão cíclica de um sinal (Duty Cycle), que é uma 
porcentagem da potência total que poderia ser entregue ao dispositivo.
A técnica de PWM é bastante aplicada na eletrônica, e pode ser utilizada 
no controle de velocidades de motores, controle de luminosidade, controle de 
servo motores. Quando uma chave está ligada, ela permite a passagem de toda 
potência, e essa potência é aplicada na carga em sua totalidade; já quando a chave 
está desligada, nenhuma potência é entregue. Se controlarmos o tempo que a 
chave fica ligada e desligada, consequentemente controlamos o valor da potência 
entregue (METTEDE, 2021). 
Para funcionamento do PWM e considerando a onda quadrada, regulamos 
a largura do pulso, o chamado Duty Cycle. Seus parâmetros são: o período e a 
largura do pulso, definida em porcentagem.
FIGURA 8 – SINAL PWM COM DUTY CYCLE DE 25%.
FONTE: <hhttp://www.squids.com.br/arduino/index.php/projetos-arduino/projetos-squids/basico/264-
projeto-80-interrupcao-por-timer-no-arduino-disparo-de-alarme-com-sensor-de-toque>. 
Acesso em: 15 jul. 2021.
TÓPICO 2 — ARDUÍNO: HARDWARE E SOFTWARE
21
Para exemplificar essa situação, podemos pensar em um sinal digital que 
oscila entre 0V e 5V com determinada frequência – o Arduíno trabalha com um 
padrão de 500Hz. Tal situação funciona como se fosse um clock, porém os tempos 
em que o sinal permanece em 0V e 5V podem ser diferentes. Duty cycle é a razão 
do tempo em que o sinal permanece em 5 V sobre o tempo total de uma oscilação. 
4 O AMBIENTE DE DESENVOLVIMENTO DO ARDUÍNO
Assim como qualquer dispositivo programável, a plataforma Arduíno 
necessita que os programas sejam desenvolvidos em uma linguagem de 
programação, compilados e posteriormente transferidos ao Arduíno. Esse 
ambiente utilizado no desenvolvimento de aplicações é denominado ambiente 
integrado de programação, chamado de IDE (Integrated Development Environment). 
A IDE Arduíno pode ser obtida gratuitamente no site do Arduíno.
Inclui um editor de código com recursos de realce de sintaxe, parênteses 
correspondentes e identificação automática. É capaz de compilar e carregar 
programas para a placa com um único clique. Depois que o programa é criado, 
ele é chamado de sketch.
Sua interface é bastante simples e didática. Além disso, outra vantagem 
é que contém, no próprio ambiente de desenvolvimento, diversas bibliotecas de 
módulos prontas para utilizar, dispensando que o usuário tenha que desenvolver 
uma programação específica para cada módulo. Tais bibliotecas são fundamentais 
para que o módulo opere corretamente.
Após baixar e instalar o software, teremos um ambiente de desenvolvimento, 
conforme ilustrado na Figura 9.
22
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
FIGURA 9 – IDE DO ARDUÍNO
FONTE: As autoras
Confira, a seguir, as funcionalidades do ambiente de desenvolvimento 
integrado do Arduino, conforme Souza (2017):
•	 Botão	Verificar: compila o sketch, verificando os erros de sintaxe do seu código. 
Na compilação, a IDE do Arduíno traduz o código escrito em linguagem C 
para a linguagem de máquina (sequência de bits, código binário), preparando 
para o armazenamento na placa do Arduíno.
• Botão Carregar: compila e, em caso de ausência de erros de sintaxe, armazena 
o código na placa do Arduíno. Em resumo, esse botão executa os mesmos 
procedimentos do botão Verificar e ainda armazena o código binário no 
Arduíno, o que faz com que a placa “rode” o seu código logo em seguida.
• Botão Novo: crua um novo sketch;
• Botão Abrir: abre um sketch e salva previamente.
• Botão Salvar: salva a sketch.
• Botão Monitor Serial: abre o monitor serial. O monitor serial é usado para ler 
um valor armazenado em uma dada variável. Observe que o monitor serial só 
pode ser aberto quando a placa de Arduíno está conectada ao computador.
TÓPICO 2 — ARDUÍNO: HARDWARE E SOFTWARE
23
Para que possamos selecionar o modelo da placa utilizada, escolhemos a 
opção Ferramentas, depois Placa, em que estará disponível todos os modelos de 
Arduíno, conforme a Figura 10. 
FIGURA 10 – ESCOLHA DA PLACA DO ARDUÍNO
FONTE: As autoras
É importante ficarmos atentos para selecionarmos a porta em que vamos 
conectar o Arduíno. Se utilizarmos o Windows, possivelmente aparecerá a COM4, 
mas isso será feito por teste de tentativa e erro. Podemos utilizar a função default 
blink, que nada mais é que o LED incluso na placa de Arduíno. Então, a partir do 
menu Arquivo, escolha Exemplos | Basics | Blink.
24
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
FIGURA 11 – O IDE DO ARDUÍNO FAZENDO CARREGAMENTO DO SKETCH BLINKFONTE: As autoras
Logo que você clicar no botão Upload, aparecerá uma barra no canto 
inferior da IDE indicando o progresso da operação enquanto o sketch está sendo 
compilado. A seguir, os LEDs rotulados como Rx e Tx deverão piscar por um 
breve tempo. Finalmente, o LED l deve começar a piscar. O IDE também exibirá 
uma mensagem como Binary sketch size:1,084 bytes (of a 32,266 byte maximum). Isso 
significa que o sketch utilizou cerca de 1 Kb dos 32 Kb de memória flash que estão 
disponíveis para programas no Arduíno (MONK, 2015).
Um programa pode ser escrito em linguagem Assembly (linguagem de 
máquina mais próxima à máquina) ou ainda podemos utilizar a linguagem C (mais 
amigável ao homem). Ainda assim, tais linguagens necessitam ser completamente 
transcritas para a máquina pelo uso de tabelas e alguns programas específicos 
que façam essa tradução.
TÓPICO 2 — ARDUÍNO: HARDWARE E SOFTWARE
25
Programas como estes geram um arquivo com extensão (.hex), que contêm 
uma sequência de caracteres ASCII, de modo geral são arquivos que contêm 
sistema de numeração hexadecimal. 
Temos um montador que permite que a instrução seja expressa em 
símbolos de fácil assimilação em caracteres alfanuméricos, utilizando instruções 
do fabricante. Além disso, monta o código com funções reconhecidas pelo 
hardware. A diferença para o compilador é que este utiliza outra programação 
não reconhecida pelo hardware. Por exemplo, a Linguagem C é muito utilizada 
para programar PIC, um exemplo de programa para gravar um dado na 
memória EEPROM.
Na ocasião em que você não tenha o Arduíno, há alguns simuladores, 
os quais utilizam o ambiente virtual para simulação de circuitos eletrônicos 
gratuitamente. Por meio de um Toolkit, ele emula as placas UNO, MEGA e NANO. 
Dessa forma, você poderá simular diversas aplicações, com interação de diversos 
componentes virtuais e até mesmo, posteriormente, enviar para um Arduíno real.
Outro benefício de utilizarmos esses ambientes virtuais é que não há 
necessidade de comprar componentes eletrônicos que não serão utilizados no 
projeto final, além de eliminar o risco de estragar componentes por conexão ou 
manipulação inapropriada deles. É ideal para iniciantes que ainda não possuem 
todas as ferramentas para começar a montar seus projetos e têm receio de cometer 
algum erro que possa danificar seus componentes (COELHO, 2021).
Algumas sugestões de simuladores, de acordo com Coelho (2021), estão 
relacionadas a seguir:
• O Tinkercard, com sua ferramenta Circuits, é a plataforma de simulação de 
circuitos mais popular entre os admiradores e a mais indicada. Podemos utilizar 
componentes básicos como LEDs, resistores, pushbuttons e potenciômetros, 
bem como simular componentes mais complexos, como módulos LCD, 
transistores, MOSFETs, CIs comparadores, amplificadores operacionais, timers 
e registradores de deslocamento.
• O Virtronics é a plataforma mais adequada para depuração de códigos mais 
complexos. Permite rodar o programa linha por linha, observar o valor das 
variáveis e os estados das portas digitais e analógicas. O programa possui 
funcionalidade gratuita limitada e é exclusivamente para computadores 
Windows. Não possui compatibilidade com componentes externos ao Arduíno. 
• O UnoArduSim é uma ferramenta para Windows ofertada gratuitamente. 
Oferece possibilidade de depuração linha por linha do código, apresenta 
simulação de alguns componentes simples como pushbuttons, chaves motoras 
DC e servos. 
26
RESUMO DO TÓPICO 2
Neste tópico, você aprendeu que: 
• O Arduíno é uma plataforma de computação física embarcada, ou seja, um 
sistema pode interagir com seu ambiente por meio de hardware e software. 
Apresenta mais de um modelo de placas e grande variedade de shields para 
complementar suas funcionalidades.
• A referência do nosso estudo será o modelo Arduíno Uno e, por esse motivo, 
aprendemos a identificar seus componentes, entradas analógicas e digitais PWM. 
• Podemos identificar os botões de verificar, carregar, novo, abrir, salvar e 
monitor serial dos sistemas relacionados ao Arduíno.
• Há algumas plataformas virtuais gratuitas para você aprender ativamente 
como trabalhar com o Arduíno UNO.
27
1 Quanto ao ciclo de programação do Arduíno, ordene os itens a seguir:
I- Aguardar a reinicialização, depois ocorrerá a execução do sketch criado.
II- Conexão da placa a uma porta USB do computador.
III- Desenvolvimento de um sketch com comando para a placa.
IV- Upload do sketch para a placa, utilizando a comunicação USB.
Assinale a alternativa que apresenta a sequência CORRETA:
a) ( ) I – IV – III – II.
b) ( ) II – I – IV – III.
c) ( ) IV – III – II – I.
d) ( ) II – III – IV – I.
2 Associe a primeira coluna com a segunda, de forma que as frases iniciadas 
na primeira coluna fiquem corretamente associadas com o seu complemento 
na segunda coluna:
I- Uma Linguagem de baixo nível.
II- Uma Linguagem de alto nível.
III- O Montador.
IV- O compilador.
V- O IDE.
( ) Permite melhor compreensão e domínio do hardware utilizado.
( ) Disponibiliza uma interface contendo o editor de texto, o compilador e 
ferramentas para debug num mesmo programa 
( ) Utiliza outra linguagem para programação que o hardware não reconhece.
( ) Utiliza apenas a linguagem Assembly, usando apenas as instruções do 
fabricante.
( ) Permite mais facilidade na abstração para a elaboração do código.
Assinale a alternativa que apresenta a ordem CORRETA:
a) ( ) III – I – II – V – IV.
b) ( ) IV – III – II – I – V.
c) ( ) IV – V – II – I – III.
d) ( ) IV – I – III – V – II.
3 No final do século XX, muitos equipamentos sofreram evoluções radicais 
em virtude da utilização dos microcontroladores, e aos poucos manipular 
computadores e softwares faz parte da realidade de grande parte da 
população. O Arduíno é uma ótima opção para motivar estudantes a colocar 
em prática esses conhecimentos de programação. Com base no exposto, 
assinale a alternativa CORRETA:
AUTOATIVIDADE
28
a) ( ) O Arduíno permite desenvolver apenas projetos de baixa complexidade, 
e esse é um dos motivos de ser utilizado para projetos didáticos.
b) ( ) Simuladores virtuais não são muito utilizados, por terem carência de 
componentes.
c) ( ) Sua placa contém alguns soquetes que permitem conectar fios ou 
Leds, um oscilador de cristal, um conector para fonte de alimentação e 
adaptador USB que permite a comunicação com o computador.
d) ( ) A programação desse dispositivo é complexa para público mais 
jovem, depende de conhecimentos prévios de arquitetura de 
microcontroladores.
4 Uma função no Arduíno consiste em gerar uma sequência de comandos a 
ser executada em cada programa; algumas destas funções são extremamente 
importantes. Disserte sobre a estrutura básica de um programa no Arduíno.
5 A função setup () e loop () são em geral executadas a cada código no 
ambiente de desenvolvimento integrado do software. Disserte sobre as 
funções setup () e loop ().
29
TÓPICO 3 — 
UNIDADE 1
PROGRAMAÇÃO DO ARDUÍNO
1 INTRODUÇÃO
Acadêmico, no Tópico 3, abordaremos a linguagem de programação do 
Arduíno. Por intermédio da linguagem de programação, conseguiremos indicar 
quais ações devam ser executadas pelo Arduíno.
 
Alguns autores consideram que sua linguagem é chamada de Wiring, 
entretanto, é consenso nos fóruns especializados que o Arduíno não é uma 
linguagem propriamente dita, e sim um dialeto da linguagem C, contendo funções 
específicas para a programação do microcontrolador AVR.
De forma simplificada, o processo de compilação começa quando o IDE 
do Arduíno faz pequenas alterações no sketch, criando um código em C++. Em 
seguida, o compilador AVR-GCC converte o código de C++ para linguagem de 
máquina (ou código objeto) para, em seguida, armazená-lo na placa do Arduíno 
via USB, como um único arquivo Intel hexadecimal COELHO, 2021). 
Para que se possa desenvolver programas para o Arduíno, as seções 
a seguir apresentarão todos os detalhes de sua linguagemde programação. 
Segundo o site oficial do Arduíno (2021), os programas escritos em Arduíno 
podem ser divididos em três partes: variáveis, funções e estruturas. Estes serão 
assuntos deste Tópico 3.
A linguagem C é dita uma linguagem de baixo nível, isto é, uma linguagem 
que é próxima da linguagem dos microcontroladores e processadores, na qual 
temos que programar registradores de bits, manipular a memória e executar 
instruções do processador. C++ é uma linguagem de alto nível, ou seja, seu 
nível de abstração é maior e ela está mais próxima da linguagem humana do 
que da dos computadores. Em linguagens de alto nível, nós não manipulamos a 
memória e os recursos de hardware diretamente, mas sim por meio de bibliotecas 
e recursos previamente disponíveis que deixam a linguagem mais transparente 
para o programador. 
A linguagem Arduíno utiliza uma série de bibliotecas e recursos para que 
o usuário não tenha que manipular bits e registradores do microcontrolador. Se 
você já programou alguma dessas linguagens, Arduíno não será um problema, e 
tais semelhanças serão evidenciadas neste tópico.
30
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
2 ESTRUTURA BÁSICA E SINTAXE DO SKETCH 
Segundo Zanetti (2015), o código-fonte é chamado de sketch. Quando 
escrevemos algum código-fonte e verificamos sua sintaxe e sua execução, 
utilizamos um compilador, cuja função é traduzir nosso código-fonte para outra 
linguagem, compreendida pelo microcontrolador. Após o processo de compilação, 
o sketch poderá ser transferido, por meio de uma conexão USB para o Arduíno.
Os programas implementados no Arduíno possuem como referência a 
Linguagem C++, preservando sua sintaxe clássica na declaração de variáveis, nos 
operadores, nos ponteiros, nos vetores, nas estruturas, por exemplo. Sua estrutura 
pode ser dividida em três partes principais.
As estruturas de referência são:
• estruturas de controle (if, else, break, ...);
• sintaxe básica (define, include, ...);
• operadores aritméticos e de comparação (+, -, =, ==, !=,...);
• operadores booleanos (||, !);
• acesso a ponteiros (*,);
• operadores compostos ()/++, -, +=, ...).
Os valores de referência são:
• tipos de dados (byte, array, int, char, ...);
• conversões (char(), byte(), int(), ...);
• variável de escopo e de qualificações (variable scope, static, volatile, ...);
• utilitário (sizeof(), diz o tamanho do espaço da variável e bytes).
Os sketchs são salvos com a extensão .ino , sua área de mensagem dá 
feedback ao salvar e exportar arquivos e também exibe informações de erros 
ao compilar. Geralmente utilizamos os seguintes componentes para elaborar 
o algoritmo: estruturas; variáveis; operadores booleanos; de comparação e 
aritméticos; estrutura de controle; funções digitais e analógicas.
A estrutura básica de um sketch é formada por duas funções principais:
• void setup(): utilizada para inicialização do programa Arduíno. Comandos 
inseridos nessa função são executados somente uma vez logo após o programa. 
• void loop(): executada indefinidamente enquanto a placa estiver ligada, pois 
seu comportamento padrão é um ciclo de repetição. Quando a última linha do 
código for executada, o sketch será lido novamente a partir da primeira linha, 
e assim sucessivamente, até que a placa seja desligada ou o botão reset seja 
pressionado.
TÓPICO 3 — PROGRAMAÇÃO DO ARDUÍNO
31
Assim como outras linguagens de programação, há um conjunto básico 
de elementos necessários para sua execução, os mais comuns são:
• o ponto e vírgula (;) obrigatório para marcar o final de uma linha de comando;
• as chaves ({ }) indicam um bloco de comandos, muito comum para definição de 
funções e estruturas de comando;
• os símbolos // ou /* */ denotam os comentários, ou seja, trechos do programa 
que serão ignorados e não executados;
• a diretiva #include é usada para incluirmos uma biblioteca de comandos. 
Exemplo:
void setup()
{
//Define a porta do led como saida
pinMode(13, OUTPUT);
}
void loop()
{
//Acende o led
digitalWrite(13, HIGH);
//Aguarda o intervalo especificado
delay(1000);
//Apaga o led
digitalWrite(13, LOW);
//Aguarda o intervalo especificado
delay(1000);
} 
Conforme Kerschbaumer (2018), a programação do Arduíno permite 
que utilizemos comentários no programa. São importantes para documentar os 
programas e facilitam a manutenção do mesmo, em virtude que poderemos ter 
centenas de linhas. Na linguagem de programação do Arduíno, os comentários 
de uma linha devem iniciar com "//", tudo que vem após as duas barras é ignorado 
pelo compilador, veja o exemplo a seguir.
void setup() {
// exemplo de comentário
}
Outra maneira de incluirmos os comentários é iniciar o código "/*" e 
finalizar com o código "*/", veja o exemplo a seguir.
/*
Exemplo de comentário
com várias linhas
*/
32
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
No Arduíno, todos os blocos de código deve ser iniciados e finalizados 
com chaves ({ }). Isso serve tanto para sub-rotinas como para instruções que 
integrem blocos de código. Veja o exemplo a seguir do que está entre o "/*" e o "*/" 
é ignorado pelo compilador (KERSCHBAUMER, 2018).
void loop() {
if(valor > 5)
{
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(1000);
}
}
Nesse exemplo, temos dois blocos de código definidos entre chaves, o 
bloco da sub-rotina ou função loop() e o bloco da instrução if. É uma boa prática 
deslocar com a tecla TAB cada bloco de código, pois assim é mais fácil visualizar 
onde cada bloco inicia e termina (KERSCHBAUMER, 2018).
3 CONSTANTES E VARIÁVEIS
Constantes são valores predefinidas e que não podem ser alterados pelo 
programador. Na linguagem de programação utilizada pelo Arduíno, há três 
grupos de constantes que podem ser utilizadas diretamente:
• HIGH e LOW: são valores referentes à tensão nos pinos digitais, sendo que 
HIGH indica 5 V, e LOW indica 0 volt.
• INPUT e OUTPUT: são valores que definem o estado de uso de um pino. 
INPUT indica entrada input) para a placa. O estado OUTPUT determina que o 
pino da placa fornecerá uma saída de valor quando, por exemplo, acendemos 
um LED, dando como saída o valor HIGH (5V).
• TRUE e FALSE: são referências para valores lógicos, ou seja, verdadeiro ou 
falso, respectivamente.
Variáveis são referências de valores armazenados em memória, para serem 
manipuladas no decorrer do código. Para utilizá-las, é necessário que estejam 
declaradas inicialmente. Tal declaração consiste em atribuir um nome para ela e 
informar qual o tipo de valor que ela armazenará. Possui o seguinte formato:
Tipo nome = valor inicial;
TÓPICO 3 — PROGRAMAÇÃO DO ARDUÍNO
33
Em que:
• tipo: pode ser um valor numérico, uma letra ou uma palavra, entre outros tipos 
de dados;
• nome: define o nome que vamos utilizar para referenciar. Os nomes podem 
conter números ou letras maiúsculas ou minúsculas. Deve iniciar com letra, e 
não pode conter espaços na formação do nome, o caractere permitido é o “_”;
• valor inicial: é um parâmetro opcional, pois uma variável pode ou não receber 
um valor inicial ao ser criado. Esse valor é atribuído pelo sinal “=”.
Vejamos agora os tipos de dados que podem ser utilizados.
3.1 TIPOS DE DADOS
As linguagens de programação são diferentes dependendo das 
plataformas computacionais. Tais características são específicas com relação 
à forma de armazenamento de dados. Há vários tipos de dados que podemos 
armazenar no Arduíno
Uma linguagem de programação apresenta dados que definem o tipo 
do valor a ser manipulado. Por exemplo, se criarmos uma variável com o nome 
“idade” e definimos que ela será do tipo numérico inteiro. Os tipos de dados mais 
utilizados estão detalhados no Quadro 2:
QUADRO 2 – TIPO DE DADOS
FONTE: Zanetti (2015, p. 29)
34
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
Segundo Kershbaumer (2018), sua sintaxe é feita da seguinte forma: 
primeiramente deve-se informar o tipo de dados utilizado, na sequência o nome 
da variável.
QUADRO 3 – TIPO DE DADOS
FONTE:Kerschbaumer (2018, p. 70)
Conforme Kerschbaumer (2018, p. 71),
O nome da variável deve iniciar com uma letra e não deve possuir 
espaços. É possível declarar mais de uma variável do mesmo tipo 
por vez, basta separar seus nomes com vírgula. Ao final da linha de 
declaração de variáveis, deve-se adicionar um ponto e vírgula. Veja a 
seguir alguns exemplos de declaração de variáveis.
int contador, valor_1;
long velocidade_do_motor;
float temperatura1;
As variáveis criadas dessa forma não possuem nenhum valor armazenado. 
No Arduíno, é possível atribuir um valor a uma variável, assim que ela é criada, 
basta adicionar o sinal de igual (=) e o valor a ser atribuído logo após o nome da 
variável (KERSCHBAUMER, 2018). Veja alguns exemplos a seguir:
int numero_de_pecas = 0; 
 float valorMaxino = 1500;
É importante salientar que não são permitidos caracteres especiais nos 
nomes de variáveis, assim letras acentuadas e o “ç” não podem ser usados 
(KERSCHBAUMER, 2018).
TÓPICO 3 — PROGRAMAÇÃO DO ARDUÍNO
35
4 OPERADORES ARITMÉTICOS, RELACIONAIS, LÓGICOS
Para realizarmos operações aritméticas nos códigos de programação, é 
necessário utilizar operadores aritméticos, assim como o emprego dos operadores 
relacionais e lógicos. Cada um desses grupos de operadores possui um conjunto 
de símbolos e respectivos significados. 
Esses operadores referenciam valores numéricos ou sobre variáveis, 
porém é importante respeitar o tipo de dados utilizado nas variáveis 
que compõe a operação. Também é possível realizar operações mais 
complexas utilizando vários operadores e, se necessário, usando 
parênteses ( ). 
A precedência desses operadores segue a lógica da matemática. 
Primeiro são avaliadas as expressões dentro dos parênteses mais 
internos, depois os incrementos e decrementos, na sequência 
as multiplicações e divisões e finalmente as somas e subtrações 
(KERSCHBAUMER, 2018, p. 72).
Além dos operadores aritméticos, também são disponibilizados vários 
operadores lógicos. No quadro a seguir são listados os operadores aritméticos 
mais utilizados na linguagem adotada no Arduíno.
QUADRO 4 – OPERADORES ARITMÉTICOS
FONTE: Zanetti (2015, p. 2)
Como podemos observar, inicialmente as variáveis são declaradas como 
int a = 10, e posteriormente a e b são somadas, resultando na variável c.
int a = 10;
int b = 5;
int c;
c = a + b;
36
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
Os valores relacionais também são muito significativos, pois permitem 
a comparação entre os valores. E o resultado de uma determinada comparação 
sempre resultará em um valor lógico (booleano), ou seja, verdadeiro (TRUE) ou 
falso (FALSE). O Quadro 4 dispões os operadores relacionais. Por exemplo, temos 
que o valor armazenado na variável booleana será TRU, pois a variável a é maior 
ou igual a b.
int a = 10;
int b = 5;
boolean result = (a>=b);
QUADRO 5 – OPERADORES RELACIONAIS
FONTE: Zanetti (2015, p. 30)
Veja a seguir os operadores lógicos.
QUADRO 6 – OPERADORES LÓGICOS
FONTE: Zanetti (2015, p. 30)
Em seguida, vemos os operadores bit a bit.
TÓPICO 3 — PROGRAMAÇÃO DO ARDUÍNO
37
QUADRO 7 – OPERADORES BIT A BIT
FONTE: Zanetti (2015, p. 31)
Conforme podemos concluir após analisar o trecho de programa a seguir, o 
valor da variável result, nesse exemplo, será FALSE. Ou seja, a variável x é maior ou 
igual a 10, resultando em TRUE, porém a variável x não é menor que 20, resultando 
em FALSE. Quando usamos o operador logico E (&&) para concatenar as duas 
expressões, teremos (TRUE && FALSE), o que produzirá um resultado FALSE. 
Pois, em uma expressão com E (AND), a saída (resultado) será verdadeira se, e 
apenas se, todos os elementos da expressão (entrada) forem verdadeiros.
int x = 30;
boolean result = ((x>=10) && (x<20));
 No trecho de programa a seguir, podemos notar um exemplo de operadores 
bit a bit, dispostos no Quadro 6. A variável a inteira x está armazenando o valor 
inteiro dois, cuja representação binária é 0000000000000010. O valor da variável 
y será obtido realizando o deslocamento à esquerda de três bits da variável x, ou 
seja, em binário, teremos 0000000000010000, que, em decimal, é o valor 16.
int x = 2; // Representação binária 0000000000000010
int y = x<< 3; // Representação binária 0000000000010000
5 ESTRUTURAS DE CONTROLE 
A estrutura de controle de fluxo determina como o programa responderá 
diante de certas condições ou parâmetros. Estruturas de decisão agrupam um 
bloco de comandos que podem ser executados ou não, dependendo do resultado 
de uma expressão lógica.
5.1 SENTENÇA IF
A estrutura de decisão mais simples que temos no Arduíno é a estrutura if 
(em português, “se”). Nela, definimos um bloco de comandos, que estão definidos 
entre as chaves { }. Esse bloco será executado somente se a expressão resultar em 
um valor TRUE (verdadeiro). Caso contrário, não será executado comando algum. 
38
UNIDADE 1 — INTRODUÇÃO À PLATAFORMA DO ARDUÍNO UNO
Podemos entender essa estrutura como sendo: se a expressão avaliada 
resultar em verdadeiro, o bloco de comando será executado. Assim, temos a 
seguir a definição da estrutura de seleção if:
//Se expressão igual a TRUE, o bloco de comandos é executado
if (expressao) {
 [bloco de comandos]
}
5.2 SENTENÇA IF...ELSE
A combinação dos comandos if…else permite maior controle sobre o 
fluxo de código que o comando if, por possibilitar que múltiplos testes sejam 
agrupados. O comando else (senão) será executado se a condição do comando if 
(se) resultar em falso. A sintaxe dos comandos if…else na programação Arduíno é:
// Se expressão igual a TRUE, o bloco de comandos-1 é executado,
// caso contrário, ou seja, a expressão igual a FALSE, o 
// bloco de comandos-2 será executado
if (expressao) {[bloco de comandos-1]
} else {
[bloco de comandos-2]
}
5.3 SENTENÇA IF...ELSE ANINHADAS
Podemos encadear várias estruturas if e else em situações em que se 
torna necessário verificar duas ou mais expressões. A seguir, podemos observar 
como realizar o encadeamento para um problema que exige a avaliação de 
duas expressões:
// Se expressão-1 igual a TRUE, o bloco de comandos-1 é executado. 
// Caso a expressão-1 seja FALSE e a expressão-2 for TRUE o bloco 
// de comandos-2 será executado. Finalmente, se a expressao-2 for 
// FALSE, o bloco de comandos-3 é executado.
if (expressão-1) { [bloco de comandos-1]
} else if(expressão-2){
[bloco de comandos-2]
} else {
[bloco de comandos-3]
}
TÓPICO 3 — PROGRAMAÇÃO DO ARDUÍNO
39
5.4 SENTENÇA SWITCH: CONDIÇÕES MÚLTIPLAS
Quando há necessidade de um encadeamento a partir de uma sequência 
de comparações com uma mesma variável, para verificarmos seu valor entre 
vários valores possíveis, podemos utilizar a estrutura switch-case, ou seja, escolha-
caso. Nessa estrutura, definimos inicialmente qual é a variável a ser comparada, 
colocando entre os parênteses da estrutura switch. Em cada um dos termos case, 
colocamos o valor a ser comparado. 
Essa estrutura é similar ao uso de if...else encadeados com a mesma variável, 
sendo comparada com expressões de igualdade, por exemplo quando queremos 
comparar se o valor de uma variável do tipo inteira é igual 1, ou se é igual a 2, ou 
se é igual a 3. A variável definida é comparada com todos os valores nos termos 
case, e quando uma das operações é TRUE, o bloco de comandos correspondente 
é executado. A sintaxe da estrutura switch-case é:
// Caso o valor da variável seja igual a valor1, o bloco de 
// comandos-1 é executado. Caso o valor da variável seja igual 
// a valor2, o bloco de comandos-2 é executado e 
// assim sucessivamente. Quando todos os cases forem FALSE o 
// bloco de comandos default é executado.
switch (variavel) {
case valor1:
[bloco de comandos-1]
break; 
case valor2:
[bloco de comandos-2] 
break;
case valorN:
[bloco de comandos-N] 
break;
default: [bloco de comandos-default]
break;
Ao final de cada bloco case, usamos o comando break, que faz com que 
a estrutura switch-case seja encerrada. Ao final da estrutura, podemos usar