Teoria de Microcontroladores e Microprocessadores

Teoria de
Microcontroladores
e Microprocessadores
Prof. Kevin Rabelo Costa
Indaial – 2021
1a Edição
Copyright © UNIASSELVI 2021
Elaboração:
Prof. Kevin Rabelo Costa
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.
C837t
Costa, Kevin Rabelo
Teoria de microcontroladores e microprocessadores. / Kevin

Rabelo Costa – Indaial: UNIASSELVI, 2021.
192 p.; il.
ISBN 978-65-5663-735-8
ISBN Digital 978-65-5663-736-5
1. Monitoramento de dados. - Brasil. II. Centro Universitário

Leonardo da Vinci.
CDD 004
Impresso por:
Apresentação
Caro acadêmico, apresentamos a você o livro de Microcontroladores
e Microprocessadores. Através dele, você terá acesso ao conhecimento
necessário para realizar os seus primeiros projetos e acompanhar uma área
que é base para as mais recentes inovações tecnológicas, como: internet das
coisas, robótica, monitoramento de dados, entre muitos outras. Esperamos
que esse livro didático seja um diferencial no seu futuro profissional.
De modo a facilitar o seu entendimento, este livro foi dividido em

três unidades, apresentadas a seguir, cada uma delas com três tópicos. Ao
final de cada tópico estão presentes questões de autoatividade com o intuito
de proporcionar uma melhor retenção do conteúdo, sendo primordial
a realização delas. Lembre-se, muito em Eletrônica e Programação está
relacionado à prática e ao exercício de determinadas atividades básicas.
A Unidade 1 apresenta um panorama histórico do desenvolvimento

dos microprocessadores e microcontroladores, partindo desde o conceito
de máquinas programáveis até os últimos lançamentos nessa indústria. Na
unidade, nós estudaremos também a arquitetura de um microprocessador,
utilizando o conhecimento adquirido para o estudo do microcontrolador
Atmega328 no final da unidade.
Na Unidade 2, nós estudaremos a programação de dispositivos

microcontrolados. Teremos como ponto de partida a lógica de programação
e seguiremos estudando os principais tipos de dados e estruturas utilizadas
na linguagem C++. Ao final, nos utilizaremos desse conhecimento para
estudar o básico da placa de desenvolvimento Arduino Uno.
Na Unidade 3, desenvolveremos nossos primeiros projetos práticos,

utilizando uma visão profissional de: abordagem do problema, utilização de
recursos do microcontrolador, simulação e resultados. Nessa fase, você será
capaz de desenvolver seus primeiros projetos, a partir de um entendimento
pleno do hardware e software à disposição.
Pretendemos, assim, caro acadêmico, contribuir com a sua formação

na área através de um conteúdo bem elaborado e consoante com a tecnologia
atual.
Prof. Kevin Rabelo

NOTA
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á novi-
dades 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 diagra-
maçã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 possibilida-
de 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 assun-
to 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!
LEMBRETE
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 complemen-
tares, 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!

Sumário
UNIDADE 1 — HISTÓRIA E ARQUITETURA DOS
MICROCONTROLADORES E MICROPROCESSADORES............................ 1
TÓPICO 1 — HISTÓRIA DOS MICROCONTROLADORES

E MICROPROCESSADORES...................................................................................... 3
1 INTRODUÇÃO..................................................................................................................................... 3
2 OS PRIMEIROS COMPUTADORES................................................................................................ 4
3 EIS QUE SURGEM OS TRANSISTORES....................................................................................... 6
4 OS PRIMEIROS MICROPROCESSADORES................................................................................ 8
5 MICROCONTROLADORES.............................................................................................................. 9
6 ESTADO DA ARTE............................................................................................................................ 10
6.1 LANÇAMENTOS RECENTES EM MICROPROCESSADORES............................................ 10
6.2 LANÇAMENTOS RECENTES EM MICROCONTROLADORES.......................................... 11
RESUMO DO TÓPICO 1..................................................................................................................... 14
AUTOATIVIDADE............................................................................................................................... 15
TÓPICO 2 — ARQUITETURA DE UM MICROPROCESSADOR.............................................. 19

1 INTRODUÇÃO................................................................................................................................... 19
2 UNIDADE LÓGICO ARITMÉTICA – ULA.................................................................................. 20
3 UNIDADE DE CONTROLE............................................................................................................. 21
4 REGISTRADORES............................................................................................................................. 23
5 BARRAMENTOS................................................................................................................................ 24
6 SET DE INSTRUÇÕES...................................................................................................................... 25
6.1 ELEMENTOS DE UMA INSTRUÇÃO....................................................................................... 25
6.2 TIPOS DE INSTRUÇÕES.............................................................................................................. 27
6.3 NÚMERO DE ENDEREÇOS........................................................................................................ 28
6.4 TIPOS DE OPERANDOS.............................................................................................................. 29
6.4.1 Números................................................................................................................................. 29
6.4.2 Dados lógicos........................................................................................................................ 30
6.4.3 Caracteres............................................................................................................................... 30
6.5 ENDEREÇAMENTO..................................................................................................................... 31
6.5.1 Imediato................................................................................................................................. 31
6.5.2 Direto...................................................................................................................................... 31
6.5.3 Indireto................................................................................................................................... 32
6.5.4 Por registrador...................................................................................................................... 32
6.5.5 Indexado................................................................................................................................ 32
6.5.6 Base mais deslocamento ..................................................................................................... 33
7 AS ARQUITETURAS RISC E CISC................................................................................................ 33
8 AS ARQUITETURAS VON NEUMANN E HARVARD............................................................. 35
RESUMO DO TÓPICO 2..................................................................................................................... 37
AUTOATIVIDADE............................................................................................................................... 39
TÓPICO 3 — O MICROCONTROLADOR ATMEGA328............................................................. 41

1 INTRODUÇÃO .................................................................................................................................. 41
2 FAMILIA AVR..................................................................................................................................... 42
3 ARQUITETURA.................................................................................................................................. 43
4 MEMÓRIAS DE PROGRAMA........................................................................................................ 46
5 MEMÓRIA DE DADOS.................................................................................................................... 48
6 REGISTRADORES............................................................................................................................. 49
7 INTERRUPÇÕES................................................................................................................................ 52
8 PINAGEM............................................................................................................................................ 53
LEITURA COMPLEMENTAR............................................................................................................. 56
RESUMO DO TÓPICO 3..................................................................................................................... 61
AUTOATIVIDADE............................................................................................................................... 63
REFERÊNCIAS....................................................................................................................................... 66
UNIDADE 2 — PRIMEIROS PASSOS NA PROGRAMAÇÃO

DE DISPOSITIVOS MICROCONTROLADOS.....................................................................69
TÓPICO 1 — INTRODUÇÃO À LINGUAGEM DE PROGRAMAÇÃO C++........................... 71

1 INTRODUÇÃO................................................................................................................................... 71
2 LÓGICA DE PROGRAMAÇÃO...................................................................................................... 72
2.1 DESCRIÇÃO . ................................................................................................................................ 72
2.2 FLUXOGRAMA ............................................................................................................................ 73
2.3 PSEUDOCÓDIGO ........................................................................................................................ 74
3 A LINGUAGEM C++.......................................................................................................................... 75
4 TIPOS DE DADOS E VARIÁVEIS................................................................................................. 76
4.1 TIPOS DE DADOS......................................................................................................................... 76
4.2 DECLARANDO VARIÁVEIS....................................................................................................... 77
4.3 CONSTANTES .............................................................................................................................. 79
5 OPERADORES LÓGICOS E RELACIONAIS.............................................................................. 80
5.1 OPERADORES RELACIONAIS.................................................................................................. 80
5.2 OPERADORES LÓGICOS............................................................................................................ 81
6 ESTRUTURAS DE SELEÇÃO.......................................................................................................... 83
7 ESTRUTURA DE REPETIÇÃO........................................................................................................ 85
8 VETORES............................................................................................................................................. 88
9 STRINGS.............................................................................................................................................. 89
10 FUNÇÕES........................................................................................................................................... 90
RESUMO DO TÓPICO 1..................................................................................................................... 94
AUTOATIVIDADE............................................................................................................................... 95
TÓPICO 2 — APRESENTAÇÃO DA PLACA DE DESENVOLVIMENTO ARDUINO.......... 97

1 INTRODUÇÃO .................................................................................................................................. 97
2 HARDWARE E SOFTWARE LIVRE .............................................................................................. 98
3 A FAMILIA ARDUINO................................................................................................................... 100
3.1 ARDUINO UNO.......................................................................................................................... 101
3.2 ARDUINO NANO....................................................................................................................... 101
3.3 ARDUINO LEONARDO............................................................................................................ 101
3.4 ARDUINO MEGA....................................................................................................................... 102
4 ARQUITETURA................................................................................................................................ 102
RESUMO DO TÓPICO 2................................................................................................................... 105
AUTOATIVIDADE............................................................................................................................. 106
TÓPICO 3 — CONFIGURANDO E CONHECENDO A IDE DO ARDUINO........................ 109

1 INTRODUÇÃO................................................................................................................................. 109
2 INSTALAÇÃO E CONFIGURAÇÃO DA IDE............................................................................ 110
3 CONECTANDO O ARDUINO...................................................................................................... 112
4 FUNÇÕES SETUP() E LOOP()....................................................................................................... 114
5 MONITOR SERIAL.......................................................................................................................... 115
6 ENVIANDO O PRIMEIRO SKETCH........................................................................................... 116
7 IMPORTANDO BIBLIOTECAS.................................................................................................... 118
LEITURA COMPLEMENTAR........................................................................................................... 122
RESUMO DO TÓPICO 3................................................................................................................... 128
AUTOATIVIDADE............................................................................................................................. 129
REFERÊNCIAS..................................................................................................................................... 131
UNIDADE 3 — DESENVOLVIMENTO DE PROJETOS COM ARDUINO............................ 133
TÓPICO 1 — SIMULANDO O ARDUINO ATRAVÉS DO TINKERCAD.............................. 135

1 INTRODUÇÃO................................................................................................................................. 135
2 PRIMEIROS PASSOS COM O TINKERCAD............................................................................ 136
3 AJUSTANDO PARAMÊTROS....................................................................................................... 139
3.1 OSCILOSCÓPIO.......................................................................................................................... 140
3.2 GERADOR DE FUNÇÃO........................................................................................................... 141
3.4 FONTE DE ENERGIA................................................................................................................. 142
3.3 MULTÍMETRO............................................................................................................................. 142
4 DEPURADOR.................................................................................................................................... 143
5 ADICIONANDO BIBLIOTECAS.................................................................................................. 144
6 EXEMPLO PRÁTICO....................................................................................................................... 145
RESUMO DO TÓPICO 1................................................................................................................... 148
AUTOATIVIDADE............................................................................................................................. 149
TÓPICO 2 — EXPLORANDO RECURSOS NATIVOS DO ARDUINO.................................. 151

1 INTRODUÇÃO................................................................................................................................. 151
2 ENTRADAS E SAÍDAS DIGITAIS............................................................................................... 151
3 CONVERSORES ANALÓGICO-DIGITAIS............................................................................... 152
4 SAIDAS PWM................................................................................................................................... 155
5 TRANSMISSÃO SERIAL............................................................................................................... 158
6 TIMERS............................................................................................................................................... 160
RESUMO DO TÓPICO 2................................................................................................................... 164
AUTOATIVIDADE............................................................................................................................. 165
TÓPICO 3 — PROJETOS COM SENSORES E ATUADORES................................................... 167

1 INTRODUÇÃO................................................................................................................................. 167
2 CONHECENDO OS SENSORES E ATUADORES.................................................................... 167
2.1 SENSORES DE LUMINOSIDADE............................................................................................ 168
2.2 SENSORES DE TEMPERATURA.............................................................................................. 169
2.3 SENSORES DE DISTÂNCIA...................................................................................................... 171
2.4 MOTOR CC................................................................................................................................... 172
2.5 MOTOR DE PASSO..................................................................................................................... 174
2.6 DISPLAY LCD.............................................................................................................................. 175
3 PROJETO DE UM POSTE ELETRÔNICO.................................................................................. 176
4 PROJETO DE UM ALARME DE PRESENÇA............................................................................. 178
5 PROJETO DE UM TERMÔMETRO DIGITAL........................................................................... 179
LEITURA COMPLEMENTAR........................................................................................................... 183
RESUMO DO TÓPICO 3................................................................................................................... 189
AUTOATIVIDADE............................................................................................................................. 190
REFERÊNCIAS..................................................................................................................................... 192
UNIDADE 1 —
HISTÓRIA E ARQUITETURA DOS

MICROCONTROLADORES E
MICROPROCESSADORES
OBJETIVOS DE APRENDIZAGEM
A partir do estudo desta unidade, você deverá ser capaz de:
• conhecer a evolução da tecnologia de microprocessadores e microcon-

troladores, através da análise de fatos históricos e detalhes de arquite-
tura;
• entender a arquitetura e organização dos processadores, bem como cada
módulo se comunica para realizar o processamento de dados;
• compreender os detalhes construtivos do Atmega328, microcontrolador
presente no Arduino Uno;
• compreender como é realizada a configuração de um microcontrolador
em nível de máquina.
PLANO DE ESTUDOS
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 – HISTÓRIA DOS MICROCONTROLADORES e

MICROPROCESSADORES
TÓPICO 2 – ARQUITETURA DE UM MICROPROCESSADOR
TÓPICO 3 – O MICROCONTROLADOR ATMEGA328
CHAMADA
Preparado para ampliar seus conhecimentos? Respire e vamos

em frente! Procure um ambiente que facilite a concentração, assim absorverá
melhor as informações.
1
2
UNIDADE 1 TÓPICO 1 —
HISTÓRIA DOS MICROCONTROLADORES E

MICROPROCESSADORES
1 INTRODUÇÃO
A automatização de tarefas, ou as rotinas, como é mais comum falarmos,
estão presentes na vida de todos. Você, todos os dias acorda e, provavelmente,
escova os dentes, arruma a cama e toma café da manhã, antes de iniciar seus estudos
ou outra atividade. As rotinas são ações sequenciais realizadas diariamente,
que você realiza muitas vezes sem perceber e de forma automática. Da mesma
forma que uma rotina, como ir à academia todos os dias, pode ser aprendida,
as máquinas podem ser programadas para executar uma sequência de ações
ininterruptamente. Hoje isso já é extremamente comum: você programa o seu
despertador para tocar todos os dias no mesmo horário, programa a sua geladeira
para manter acima de uma determinada temperatura, ou a sua Alexa para dizer
“Oi” quando você chegar em casa. Mas nem sempre foi assim. As primeiras
máquinas consideradas programáveis não eram nem elétricas. Como você vai
ver nesse tópico foi preciso longos anos de estudo para chegar onde chegamos.
Mesmo a humanidade já tendo avançado bastante, a ponto de chegarmos a
miniaturizações como o celular, ainda existe espaço para muito mais.
O estudo histórico dos microprocessadores e microcontroladores

é principalmente importante para acompanharmos as tendências na área.
Como esses dispositivos evoluíram? Qual a tendência dessa evolução? Está
na miniaturização? Está na velocidade de processamento? Isso tudo além de
estudarmos a tecnologia que foi utilizada na época, porque ao contrário do que se
pensa, muita tecnologia dita “antiga” ainda é usada atualmente nos mais diversos
dispositivos, como veremos neste tópico.
Pensando nisso, você estudará como os computadores se desenvolveram

até chegarem às máquinas complexas que são hoje e que servem como bases para
as mais diversas aplicações. Dessa forma, a leitura desse tópico agregará a você,
acadêmico, não apenas o conhecimento histórico do assunto, mas também a base
tecnológica que levou à evolução dos computadores. Assim, você terá, ao fim deste
tópico, a base necessária para iniciar o estudo efetivo dos microcontroladores e
microprocessadores de que trataremos no restante desse livro.
3
UNIDADE 1 — HISTÓRIA E ARQUITETURA DOS MICROCONTROLADORES E MICROPROCESSADORES
2 OS PRIMEIROS COMPUTADORES
Em vez de já irmos explorando os primeiros computadores, é interessante
primeiro entendermos por que eles surgiram. Como vimos, o nosso dia a dia
é formado de rotinas, em outras palavras, atividades repetitivas, que fazemos
sempre da mesma forma e normalmente com os mesmos materiais. Ao longo da
história a tendência sempre foi de melhorar mais esses processos, de forma a deixá-
los mais rápidos, menos onerosos e mais simples. Foi a partir dessa tendência de
facilitar processos que surgiram as primeiras máquinas programáveis. A primeira
delas, conforme afirma Pereira (2009), foram os teares, que eram programadas
através de cartões perfurados para repetir padrões em tecidos. Essas máquinas
são consideradas as percussoras dos computadores justamente por exibir esse
padrão programado e repetitivo que vemos ainda hoje em vários códigos
computacionais.
Há ainda quem afirme que os computadores surgiram da necessidade de

se fazer cálculos de forma rápida e precisa. De qualquer modo, as calculadoras
também são consideradas parte importante no processo de concepção dos
computadores. Caso você esteja se perguntando, a primeira calculadora foi
inventada por William Schickard, ainda no início do século XVII. Ela era mecânica
e capaz de realizar as quatro operações básicas em um girar de alavancas.
Durante muito tempo se achou que a primeira calculadora foi inventada por
Pascal, contudo após o estudo de cartas trocadas entre Schickard e Kepler, se
descobriu que o alemão, na verdade, estava 20 anos adiantado em relação à Pascal
(WAZLAWICK, 2017). A Figura 1 apresenta a vista da famosa Pascaline, criada
por Pascal. Apesar da importância histórica, essas máquinas não são consideradas
programáveis, simplesmente por não haver a entrada de instruções informando o
que fazer com os números.
FIGURA 1 – PASCALINE, DURANTE MUITO TEMPO FOI CONSIDERADA A PRIMEIRA

CALCULADORA A SER INVENTADA
FONTE: <https://www.britannica.com/technology/Pascaline>. Acesso em: 23 mar. 2021.
4
TÓPICO 1 — HISTÓRIA DOS MICROCONTROLADORES E MICROPROCESSADORES
Os cartões perfurados no qual os teares são baseados foram utilizados ainda

em várias outras máquinas até chegarem ao engenheiro alemão Konrad Zuse,
que construiu o primeiro computador eletromecânico utilizando-se dos cartões
perfurados e relés, o Z1. Para você entender melhor, os relés foram inventados
anos antes por Joseph Henry, e se utilizavam de um fenômeno eletromagnético
conhecido como indução magnética. Vamos entender melhor esse fenômeno:
basicamente, ao induzirmos uma corrente elétrica em um enrolamento de fios,
um campo magnético é gerado, sendo capaz de atrair objetos metálicos, da mesma
forma que um ímã. A partir desse princípio, o relé, formado por uma bobina e
um contato móvel metálico foi utilizado para gerar estados binários de zeros e
uns. Inicialmente, com a bobina desenergizada, o contato permanece aberto, não
havendo condução de corrente, o que corresponde digitalmente ao estado “0”,
em contrapartida, ao energizar a bobina, o campo magnético gerado aproxima o
contato, permitindo o fluxo de corrente, o que corresponde ao estado digital “1”.
Na Figura 2, você confere o esquema prático de um relé, bem como os estados
de comutação que falamos. Vale dizer que apesar dos relés terem proporcionado
grandes ganhos em relação às máquinas mecânicas, estes ainda era muito lentos
e foram rapidamente substituídos pelas válvulas mecânicas na construção de
computadores.
NTE
INTERESSA
Apesar de os relés não terem sido utilizados por muito tempo na construção
de computadores, eles são utilizados ainda hoje, principalmente para o chaveamento de
cargas em corrente alternada. Um exemplo interessante é o acionamento remoto de uma
lâmpada através de um microcontrolador. O relé permite, nesse caso, o acionamento de
uma carga em corrente alternada, normalmente conectada em 220V ou 110V, através de
um pulso de 5V gerado pelo microcontrolador.
Um dos primeiros computadores à válvula conhecido foi o famoso

ENIAC, fabricado pelo EUA durante a segunda guerra mundial. Apesar de ser
extremamente pesado (em torno de 27 toneladas), e consumir em torno de 150
kW, o ENIAC apresentou um grande avanço em relação ao seu antecessor Mark
I, que operava a 8Hz enquanto o ENIAC chegava a alcançar 5 kHZ (TECHTUDO,
2012). O ENIAC também foi o primeiro computador a utilizar a arquitetura
Von Neumman, que como veremos adiante, é utilizada até hoje em certos
microprocessadores.
Mesmo com a capacidade de programação, os computadores anteriores

à década de 1950, necessitavam terem cabos reposicionados, chaves ligadas
ou desligadas e um novo programa devia ser carregado sempre que houvesse
a necessidade de reprogramação (TECMUNDO, 2011). As coisas começaram a
mudar, e principalmente a diminuir, quando um certo componente foi inventado.
5
FIGURA 2 – ESTADOS DE CONDUÇÃO DE UM RELÉ
a) Estado 0: a bobina desenergizada b) Estado 1: a energização da bobina

não proporciona o campo magnético proporciona a aproximação dos
necessário para unir os dois contatos. contatos e o fluxo de corrente.
FONTE: Adaptado de <https://bit.ly/371sfY4>. Acesso em: 23 mar. 2021.
3 EIS QUE SURGEM OS TRANSISTORES

O grande mérito por transformar os computadores antigos, que ocupavam
o tamanho de uma sala, em aparelhos portáteis que carregamos hoje na bolsa está
em um componente: o transistor. A invenção de Bardeen, Brattain e Shockley foi
patenteada em 1947 e revolucionou a eletrônica da época. O transistor substituiu
as válvulas eletromecânicas e deu espaço para uma redução no tamanho dos
dispositivos eletrônicos em geral.
Basicamente, o transistor é um dispositivo eletrônico composto por

pelo menos três terminais, nomeados como base, coletor e emissor. Uma tensão
aplicada na base faz com que a corrente flua entre coletor e emissor. Dessa forma,
o transistor também pode atuar como uma chave eletrônica, uma vez que uma
tensão na base permite o fluxo de corrente (chave fechada) e quando não existe
tensão, a corrente fica impedida de circular (chave aberta). Esse comportamento
reproduz os zeros e uns amplamente utilizados na computação para cálculo e
processamento de dados.
Tudo bem, mas você deve se perguntar o que levou os transistores a

serem utilizados tão amplamente na construção de computadores, uma vez que
os relés e até mesmo as válvulas replicam esse mesmo estado de zero e uns. O
grande diferencial do transistor está na velocidade e também no tamanho desses
dispositivos. Como isso é possível? De forma básica, o processo de condução do
transistor (o fluxo de corrente através dele) acontece de forma extremamente
rápida. Além disso, são necessários apenas pequenas porções de materiais
dopados para a montagem de um transistor, o que garantiu também uma
miniaturização dos computadores. A partir da sua invenção, o transistor passou a
ser utilizado na construção de computadores e também na amplificação de sinais
e na implementação de dispositivos lógicos.
6
NOTA
A dopagem eletrônica é o procedimento em que um determinado material

semicondutor é acrescido de impurezas de modo a proporcionar uma condução controlada
(PEREIRA, 2010). No caso do transistor, a condição de condução acontece quando uma
tensão é induzida no terminal base. Para saber mais sobre a relação da dopagem com
a condução de semicondutores acesse: http://www.quimica.seed.pr.gov.br/modules/
conteudo/conteudo.php?conteudo=179.
Como você deve lembrar, as portas lógicas desempenham papel

fundamental na Eletrônica Digital. Uma curiosidade é que todas as portas
lógicas podem ser recriadas utilizando transistores, assim como memórias,
microprocessadores e microcontroladores. Por isso enfatizamos tanto a
importância da invenção dos transistores. As figuras 3 e 4 apresentam uma porta
lógica AND e NOT implementadas apenas com transistores discretos.
DICAS
A fim de ampliar os conhecimentos acerca dos transistores e a sua importância

para computação, recomenda-se a leitura do seguinte artigo: https://tecdicas.com/criando-
portas-logicas-com-transistores/.
FIGURA 3 – IMPLEMENTAÇÃO DE UMA FIGURA 4 – IMPLEMENTAÇÃO DE UMA

PORTA AND USANDO TRANSITORES PORTA NOT USANDO TRANSISTORES
FONTE: O autor (2021) FONTE: O autor (2021)
7
O surgimento dos transistores proporcionou um grande avanço na

computação da época: computadores passaram a ser produzidos de forma menos
dispendiosa, em menor espaço e consumindo menos energia. É aí que nascem os
primeiros microprocessadores, como veremos a seguir.
4 OS PRIMEIROS MICROPROCESSADORES
No final dos anos 1960, os transistores passaram a ser utilizados na
construção dos mais diferentes tipos de circuitos lógicos. Entre eles, começaram
a surgir dispositivos capazes de executar sequência de instruções, assim como os
microprocessadores modernos. Inicialmente, esses circuitos eram formados pela
conexão discreta de diversos circuitos integrados e transistores. Só no início da
década de 1970 surgiram os primeiros microprocessadores totalmente integrados
e encapsulados em um único chip, como conhecemos hoje (TECHTUDO, 2012).
Conforme afirma Pereira (2009), o primeiro microprocessador foi lançado

em 1969 pela Intel e ficou conhecido na época como i4004. O chip era destinado
para o desenvolvimento de calculadoras, e possuía na época 4 bits, cerca de 46
instruções, um clock base de 740 kHz, e era o resultado do encapsulamento de
mais de 2000 transistores em um único chip. A vista do i4004 pode ser vista na
Figura 5.
FIGURA 5 – INTEL I4004: CONSIDERADO O PRIMEIRO MICROPROCESSADOR DA HISTÓRIA.
FONTE: <https://bit.ly/376u8Tw>. Acesso em: 15 jul. 2021.
O i4004 deu início a um intenso desenvolvimento tecnológico nos

anos subsequentes. Como veremos, a busca a partir de agora foi por viabilizar
dispositivos cada vez mais rápidos. Em 1972, a Intel lançou o i8008, processador
de 8 bits, com barramento externo de 14 bits e capaz de endereçar 48 instruções e
um clock de 800 kHz. O sucesso do i8008 foi tão grande que o microprocessador
passou a integrar os primeiros computadores pessoais da época.
O i8008 foi o percursor de um dos microprocessadores mais importantes

da história: o i8080, o primeiro microprocessador a implementar um barramento
de 16 bits, com clock de 3 MHz e 78 instruções. O i8080 equipou o IBM-PC,
8
enquanto o Macintosh da Apple foi equipado com os processadores 6800 da

Motorola, que também já concorria nesse mercado na época.
Foi com base no i8080 que surgiram a família de processadores x86. O

primeiro processador da família, o i8086, alcançou um clock com velocidade
de 5 MHz, usando instruções de 16 bits. A família x86 foi lançada no final da
década de 70 e ainda serve como base para boa parte dos computadores atuais
(TECHTUDO, 2012).
5 MICROCONTROLADORES
Você já deve ter percebido que nos computadores modernos os
microprocessadores não atuam de forma autônoma, sendo necessários
componentes externos como: memória RAM (para armazenamento de dados
e variáveis) e memória ROM (para armazenamento de programas), além de
geradores de clock externo, endereçamento, dispositivos de regulação, entre
outros. A partir dessa necessidade, surgiu ainda em meados de 70, o primeiro
MCU (Micro Controller Unit), ou microcontroladores como passaremos a chamar
aqui. O primeiro microcontrolador foi inventado pela Texas Instrument e era
basicamente o encapsulamento de um microprocessador com memórias RAM e
ROM integradas (AUGARTEN, s.d.).
Ao contrário dos microprocessadores, um microcontrolador já possui

todos os dispositivos necessários para o seu funcionamento integrados em um
mesmo chip. Como veremos mais adiante, muitos microcontroladores hoje já
possuem até tecnologias como Bluetooth e WiFi integradas, além de diversos
protocolos de comunicação.
Os primeiros microcontroladores derivaram também do i8080. Chips

como o 8048, e posteriormente o 8050 da Intel, se tornaram os mais populares na
época e os mais utilizados em tarefas de automação.
Nos anos subsequentes, os microcontroladores continuaram evoluindo

para chips mais rápidos, mas ainda havia uma limitação nesses dispositivos: a
reprogramação. Geralmente era necessária programação especializada (realizada
pelo próprio fabricante), mudança de hardware e a remoção do dispositivo
do circuito, o que deixava o desenvolvimento mais lento e mais oneroso. Foi
com o desenvolvimento das memórias flash, durantes os anos 1990, que os
microcontroladores passaram a ser programados ou apagados através de sinais
elétricos, não sendo necessário nem a retirada do dispositivo do circuito, nem
muito menos o retorno ao fabricante (AYCOCK, 2017). Atualmente fabricantes
como Microchip e Atmel se utilizam largamente desse tipo de memória para os
seus dispositivos.
9
Além dos microcontroladores, outros tipos de microprocessadores

merecem destaque. Os processadores de sinais digitais, ou DSPs, como são
conhecidos, são tipos de microprocessadores empregados no processamento
de sinais digitais, estando presentes em televisões digitais e em aparelhos de
CD e DVD. Já as GPU são chips especializados em processar gráficos. É muito
comum hoje que alguns processadores já venham com uma GPU integrada para
o processamento de vídeo e jogos em geral.
6 ESTADO DA ARTE
As aplicações para microcontroladores e microprocessadores crescem
dia após dia, do mesmo modo que a pesquisa nessas áreas. A necessidade por
miniaturização e eficiência trouxe a eletrônica a um nível fantástico nos dias de
hoje. Em menos de 70 anos, computadores passaram de dispositivos imensos
para pequenas telas que carregamos no nosso bolso, e não para por aí. A seguir
é apresentado o estado da arte de microcontroladores e microprocessadores, o
que nada mais é do que estado atual de conhecimento nessa área. Por ser uma
área muito grande e com diversas ramificações, principalmente, no que se
refere às aplicações dessas tecnologias, focaremos nos lançamentos recentes de
microprocessadores e microcontroladores que estão ao nosso alcance, e que como
profissionais da área temos grandes chances de um dia chegar a trabalhar com
eles.
DICAS
Artigos que apresentam o estado da arte de uma determinada tecnologia

são sempre bem-vindos pela comunidade acadêmica por servirem de base para vários
outros trabalhos. Que tal se aprofundar no estado da arte de microprocessadores e
microcontroladores, se juntar com um ou mais colegas e escrever um artigo?
6.1 LANÇAMENTOS RECENTES EM MICROPROCESSADORES

Os microprocessadores estão presentes na maioria dos equipamentos
eletrônicos que conhecemos hoje: celulares, tablets, notebooks, placas de vídeos,
servidores, bombas de gasolina, máquinas de cartão de crédito, dispositivos
médicos, se utilizam de algum tipo de microprocessador para gerar valor à
sociedade. Cada microprocessador serve perfeitamente para cada aplicação,
o que significa que são escolhidos de acordo com os requisitos práticos. Os
microprocessadores presentes nos computadores modernos, por exemplo,
possuem uma capacidade de processamento de dados bem maior que uma
máquina de cartão de crédito, mas são ainda normalmente menores em capacidade
10
que os dos servidores. Como você verá na sua trajetória profissional, cada centavo
economizado na escolha correta de um componente eletrônico, significa uma
economia de milhares em equipamentos que são produzidos em série.
Como você deve imaginar, os microprocessadores continuaram evoluindo

em velocidade, recursos e capacidade de processamento.
Já a AMD lançou recentemente, em janeiro de 2021, a nova linha de

processadores Ryzen 5000, com arquitetura Zen 3 para notebooks. Segundo a
fabricante, o Ryzen 7 5800U promete ser o melhor processador para notebooks
ultrafinos, com 8 núcleos e clock de até 4,4 GHz, além de ter melhor eficiência
energética, capaz de reproduzir vídeos por 21 horas com uma única carga. Para
desktops (computadores de mesa) a empresa lançou o Ryzen 9 5900, com incríveis
12 núcleos e performance até 24% melhor em jogos que o seu antecessor.
6.2 LANÇAMENTOS RECENTES EM

MICROCONTROLADORES
Recentemente, em janeiro de 2021, a empresa Raspberry anunciou o
lançamento da Raspberry Pi Pico, por um valor de aproximadamente $4. A placa
é baseada no microcontrolador RP2040, o primeiro desenvolvido pela empresa
e conta com dois núcleos, um clock base de 133 MHz (perceba a diferença em
relação aos primeiros micros), memória RAM de 256 kB e flash de 2MB, além de
possuir 30 pinos GPIO (pinos com opção de uso como entrada ou saída de dados,
exploraremos mais sobre isso adiante), sensor de temperatura e comunicação SPI,
I2C, UART, integradas (RASPBERRY, s.d.). A placa foi desenvolvida para ser uma
opção de baixo custo para desenvolvimento de protótipos. O microcontrolador
vai equipar ainda outras placas com o Arduino Nano RP2040 e o Adafruit Feather
RP2040.
E
IMPORTANT
A Raspberry Pi Pico trata-se de uma placa de desenvolvimento, enquanto

o RP2040 é o microcontrolador que integra essa placa. As placas de desenvolvimento
normalmente são mais indicadas para iniciantes por possuir toda a estrutura para a
aprendizagem, como: interface para programação via USB, regulação de tensão, pinos para
conexão com os GPIOs e outras facilidades.
Uma das pioneiras em placas de desenvolvimento foi a Arduino. O intuito

desde o início era criar um dispositivo que fosse barato, fácil de programar e
acessível para estudantes e projetistas amadores. Assim, surgia o Arduino Uno,
11
baseado no microcontrolador Atmega328 da Atmel, e facilmente programado

em C++, através da conexão USB ao computador. Depois de programada a placa
pode ser conectada e usada de forma independente para o acionamento de um
robô, controle de temperatura, acionamento remoto de bombas e muitas outras
aplicações. Existem placas Arduino para as mais diversas aplicações sendo as
mais comuns o Arduino Uno, o Nano e o Mega.

Com o recente desenvolvimento do conceito de Internet das Coisas (IoT),
mais e mais projetos passaram a ter como premissa a conexão com a Internet.
Vendo essa necessidade, placas de desenvolvimento com o ESP8266, e o seu
sucessor, o ESP32 surgiram. Essas placas contam com módulos de conexão WiFi
e Bluetooth integrados, facilitando o desenvolvimento para a área de IoT.
Contudo, nem sempre as placas de desenvolvimento são a melhor opção.

Em projetos comerciais que requerem protótipos menores, é comum a utilização
do microcontrolador em si, sem todo o aparato que as placas de desenvolvimento
possuem. Microcontroladores muito utilizados nesse tipo de aplicação são os PICs.
Os PICs são gravados através da conexão de pinos específicos do microcontrolador
com o PICKIT, que por sua vez se conecta ao computador via cabo USB. Os
microcontroladores PIC possuem famílias com núcleos de processamento de 8,
16 e mais recentemente de 32 bits e atingem velocidades de até 48 MHz.
Voltados normalmente para aplicações de maior desempenho, temos a

nova linha de microcontroladores STM32G0, da fabricante ST. Lançados em 2019,
os microcontroladores são uma boa opção para aplicações industriais, oferecendo
uma memória RAM de até 128 kB e flash de até 512 kB (SEMICONDUCTORS,
s.d.).
Para você ter uma ideia de como os microcontroladores desempenham

papel fundamental no desenvolvimento de novos projetos, vamos analisar alguns
dos mais interessantes a seguir.
A fim de reduzir o tempo gasto procurando por vagas de estacionamento

e, consequentemente, a poluição, Melnyk, Djahel e Nait-Abdesselam (2019)
propuseram uma solução inteligente que verifica as vagas disponíveis em um
estacionamento e disponibiliza ao usuário através de um aplicativo Android, de
modo que ele possa ir diretamente a vaga indicada. O papel do microcontrolador
nessa aplicação é receber os dados dos sensores que indicam se determinada vaga
está ocupada ou não.
Já Mtshali e Khubisa (2019) propuseram um sistema de casas inteligentes

voltados para pessoas com deficiência física. Através do sistema o usuário
consegue ligar e desligar aparelhos e ainda pedir ao assistente virtual que mostre
o interior desses aparelhos. O sistema conta ainda com sistema de monitoramento
em caso de queda da pessoa com deficiência e chama imediatamente o serviço de
saúde mais próximo.
12
Os incêndios florestais sejam eles espontâneos ou criminosos, resultam

em grandes perdas para fauna e flora local. Dessa forma, Zhu, Xie e Yuan (2012)
propuseram um sistema de monitoramento capaz de coletar informações de fogo
na floresta em qualquer momento, sendo possível prevenir o incêndio, em seu
estágio inicial.
Em muitas cidades, a alta incidência de crimes se torna um problema para

o governo, e o efetivo de policiais, muitas vezes, não é suficiente para monitorar
todos os pontos. Assim, surgiram aplicações, como apresentado por Singh et al.
(2018), que utilizam de microprocessamento de imagens para detectar e alertar
sobre movimentos considerados perigosos ou violentos.
A grande variedade de microcontroladores vista atualmente facilita

bastante a implementação dos mais diversos projetos, e, como vimos, proporciona
avanços significativos no bem-estar da sociedade. E você, tem ideias que seriam
possíveis com o uso de microcontroladores?
13
RESUMO DO TÓPICO 1
Neste tópico, você aprendeu que:
• Os microprocessadores evoluíram de dispositivos eletromecânicos que

pesavam toneladas para pequenos chips que integram a maioria dos
dispositivos eletrônicos de que conhecemos hoje.
• A invenção do transistor representou um grande avanço para o desenvolvimento

da computação, por ser uma chave mais compacta, econômica e confiável que
as antecessoras eletromecânicas.
• Os transistores são a base de diversos dispositivos lógicos como

microprocessadores, memórias e portas lógicas.
• Enquanto os microprocessadores precisam de componentes externos para

funcionar, como: memórias RAM e ROM, endereçadores e clocks externos,
os microprocessadores já possuem todos esses componentes internos e
encapsulados em um único CI.
• Além dos microcontroladores, outros tipos de microprocessadores são

importantes e estão presentes no nosso dia a dia, como: as GPUs, responsáveis
pelo processamento de gráficos, e os DSPs, responsáveis pelo processamento
de sinais digitais.
• Placas de desenvolvimento normalmente são melhores para iniciantes por já

virem com todo o hardware necessário para o desenvolvimento de protótipos.
• O mercado na área de microprocessadores cresce a cada ano, e que os

principais fabricantes: Intel e AMD, fazem lançamentos anuais buscando
sempre reduzir custo, melhorar a capacidade de processamento e velocidades
dos chips.
• Vários fabricantes de microcontroladores estão alinhados com as novas

tendências, estando disponíveis no mercado placas de desenvolvimento como
o ESP32 que já possuem módulos WiFi e Bluetooth integrados, voltados para
o desenvolvimento na área de IoT.
• A grande variedade de microcontroladores proporciona uma maior facilidade

na escolha do dispositivo de acordo com a aplicação.
• O desenvolvimento de sistemas microcontrolados vem proporcionando

solução para vários problemas da sociedade.
14
AUTOATIVIDADE
1 Apesar de ter evoluído enormemente nos últimos anos, o desenvolvimento

da computação não se deu de forma linear, existindo nos primeiros
computadores problemas que propiciaram um campo para o
desenvolvimento de novas tecnologias. Acerca dos problemas presentes
nos primeiros computadores, classifique V para as sentenças verdadeiras e
F para as falsas:
( ) A capacidade de reprogramação esteve presente nos primeiros

computadores, não sendo um problema.
( ) O ENIAC, um dos primeiros computadores inventados, apresentou um
grande avanço em relação ao Mark I, apesar de possuir um consumo
elevado de energia.
( ) O relé, dispositivo eletromecânico inventado por Joseph Henry, foi
rapidamente substituído pelas válvulas por ser muito lento.
( ) A utilização dos transistores permitiu uma diminuição no tamanho
dos computadores da época, assim como uma maior velocidade de
processamento.
Assinale a alternativa que apresenta a sequência CORRETA:

a) ( ) V – V – F – F.
b) ( ) F – V – V – V.
c) ( ) V – F – F – V.
d) ( ) F – V – V – F.
2 Ao longo da história dos processadores, vários dispositivos ficaram

conhecidos e acabaram contribuindo para o desenvolvimento tecnológico
que temos hoje nessa área. Sobre os dispositivos que fizeram parte da
história dos processadores, associe os itens, utilizando o código a seguir:
I- Teares.
II- Pascaline.
III- Z1.
IV- ENIAC.
V- i4004.
( ) Deu início ao desenvolvimento dos microprocessadores como conhecemos

hoje, sendo o resultado do encapsulamento de mais de 2000 transistores.
( ) É considerado o primeiro computador eletromecânico construído, o
dispositivo funcionava a partir de cartões perfurados e relés
( ) É considerado a primeira máquina programável, seu funcionamento era
baseado na repetição de padrões gravados em cartões perfurados
( ) Acreditou-se durante muito tempo ser a primeira calculadora inventada,
quando na verdade o feito pertence a William Schickard.
15
( ) Um dos primeiros computadores a válvula a ser construído, atingindo
velocidades de até 5 kHz.

a) ( ) V – III – I – II – IV.
b) ( ) II – IV – I – V – III.
c) ( ) V – I – II – III – IV.
d) ( ) II – I – III – IV – V.
3 Apesar de serem derivados também do i8008, os microcontroladores possuem

uma topologia diferente dos microprocessadores, servindo também para
aplicações diferentes. A respeito da diferença entre microcontroladores e
microprocessadores, assinale a alternativa CORRETA:
a) ( ) É comum que microcontroladores possuam maior velocidade de

processamento que os processadores.
b) ( ) O microcontrolador ao contrário do microprocessador possui memória
RAM e ROM, além de outros recursos, integrados em um mesmo
encapsulamento, apesar de normalmente atingir menores velocidades
de processamento.
c) ( ) O microprocessador ao contrário do microcontrolador possui memória
RAM e ROM, além de outros recursos, integrados em um mesmo
encapsulamento.
d) ( ) Projetos com microcontroladores necessitam da conexão externa de
memórias RAM e ROM, ao contrário dos microprocessadores que não
tem essa limitação.
4 A história dos computadores foi marcada por novas tecnologias, que

possibilitaram avanços na forma como esses equipamentos processavam
informações. Contudo, uma invenção em específico contribuiu
significantemente na redução do tamanho dos computadores. O que
contribuiu para o que os computadores atuais sejam significantemente
menores que os seus antecessores eletromecânicos? Justifique sua resposta.
5 Os transistores estão presentes na maioria dos eletrônicos que conhecemos

hoje: desde os computadores até as máquinas de lavar modernas possuem
esses pequenos componentes. Sabendo disso, explique o princípio elétrico
que faz com que os transistores sejam utilizados na maioria dos dispositivos
eletrônicos modernos.
6 Após a sua invenção, os transistores passaram a ser utilizados nos mais

diversos circuitos lógicos, reduzindo também o tamanho de calculadoras e
outros dispositivos matemáticos. Pesquise e explique como os transistores
podem ser utilizados para realizar uma adição simples.
16
7 Dependo da foram como são construídos, os microcontroladores podem
ser utilizados nas mais diversas aplicações, sendo esse um fator decisivo
na escolha de um componente ou outro. Sobre os microcontroladores
utilizados na indústria aeroespacial e militar, disserte acerca do que esses
dispositivos possuem de diferente dos convencionais.
17
18
ARQUITETURA DE UM MICROPROCESSADOR
1 INTRODUÇÃO
Como estudamos no Tópico 1, os microprocessadores são parte
fundamental dos computadores modernos, todo o processamento de dados,
cálculos e requisições para dispositivos periféricos passam por ele.
Ainda assim, o microprocessador depende de outros dispositivos para

funcionar: como periféricos, memórias e um barramento. De forma geral,
pode-se dizer que a união desses dispositivos com o microprocessador resulta
em um computador. Apesar da importância dos demais componentes, iremos
focar apenas na arquitetura do microprocessador propriamente dito. Você pode
visualizar a estrutura detalhada de um computador na Figura 6, nela também é
apresentada a estrutura do microprocessador, que será o alvo do nosso estudo.
FIGURA 6 – ESTRUTURA DETALHADA DE UM MICROPROCESSADOR
FONTE: Stallings (2010, p. 10)
19
A estrutura de blocos que vemos na Figura 6 se repete para a maior

parte dos fabricantes, de modo que, estudando essa estrutura básica, você
terá uma facilidade maior que entender a estrutura específica da família de
microprocessadores ou microcontroladores que por ventura você vier a estudar.
Neste tópico, além da estrutura lógica de um microprocessador, veremos

também o seu princípio de funcionamento. Assim, entenderemos como as
unidades lógicas se comunicam e qual a função de cada uma no contexto de
processamento. Esse entendimento é primordial para o desenvolvimento de
projetos robustos e otimizados, independente da linguagem de programação ou
família de processadores que você irá trabalhar.
2 UNIDADE LÓGICO ARITMÉTICA – ULA

A ULA, ou ALU (Arithmetic and Logic Unit), do inglês, é a unidade do
microprocessador responsável pelas operações lógicas e aritméticas como: soma,
subtração, multiplicação, divisão, comparação, diferenciação e outras. Conforme
afirma Stallings (2010), a ULA é a essência do processador, e pode ser considerada
umas das partes mais importantes pelo simples fato de receber e processar dados
de todos as outras partes do processador.
Dito isso, vamos analisar como ela funciona. A ULA possui basicamente
duas entradas: uma para os registradores e outra para a unidade de controle, e
duas saídas: uma de flags e a outra de registradores. Sempre que uma operação for
realizada, os dados a serem calculados são apresentados através de registradores
(que como veremos mais adiante armazenam esses valores), ao passo que a
unidade de controle informa o que deve ser feito com eles. A ULA realiza então
essa operação e o resultado é armazenado novamente em um registrador. Ao
final da operação uma flag pode ainda ser gerada. As flags normalmente passam
alguma informação ao bloco que receberá o resultado. Ao executar uma operação
de soma em que o resultado for maior que o espaço destinado para o seu
armazenamento, por exemplo, uma flag de overflow (transbordamento, em uma
tradução direta) é gerada informando que o resultado não foi corretamente salvo
no registrador por conta do espaço disponível ser insuficiente.
Dessa forma, a ULA funciona com uma calculadora que recebe comandos
através da unidade de controle e entrega esses dados através de registradores as
demais partes do microprocessador.
20
TÓPICO 2 — ARQUITETURA DE UM MICROPROCESSADOR
3 UNIDADE DE CONTROLE
Chegamos à unidade de controle do microprocessador. Você tem ideia
do que essa unidade faz? Bem, a unidade de controle é quem gera os gatilhos
para que ações sejam tomadas dentro do processador. Basicamente, a unidade de
controle emite sinais para dispositivos externos ao processador como: periféricos
e memórias, e internamente para a ULA, de modo que determinada função interna
seja realizada, recebendo como entrada instruções, flags e sinais de controles de
fontes externas, através dos registradores. Em termos práticos podemos dizer que
a unidade de controle é quem garante a correta execução das tarefas, ou instruções
como passaremos a chamar daqui em diante, no microprocessador. Veremos a
seguir como as instruções são processadas, dessa forma, entenderemos melhor
como a unidade de controle funciona.
LEMBRETE
Como você deve se lembrar, uma das entradas da ULA vem justamente da
unidade de controle. É ela que informa a ULA o que deve ser feito com os dados nos
registradores.
A operação de um programa depende da execução de uma sequência de

instruções, como uma lista de tarefas que executamos ao longo dia. Contudo,
como é descrito a seguir, as instruções ainda não são as menores unidades de
execução de um programa.
[...] Para resumir, a execução de um programa consiste da execução

sequencial de instruções. Cada instrução é executada durante um ciclo
de instrução feito de subciclos menores (por exemplo, busca, indireto,
execução, interrupção). A execução de cada subciclo envolve uma ou
mais operações mais curtas, ou seja, micro-operações (STALLINGS,
2010, p. 462).
Pode parecer complexo, mas na verdade tudo o que foi falado aqui pode
ser resumido na Figura 7.
21
FIGURA 7 – ESTRUTURA DE EXECUÇÃO DE UM PROGRAMA
NOTA
O ciclo de máquina se refere ao tempo que um processador leva para finalizar

um ciclo de clock, ou, como vimos anteriormente, para executar uma instrução. Esse
tempo é inversamente proporcional a frequência de clock do processador. Ou seja,
Onde t é o ciclo de máquina e f a frequência do clock do microprocessador.

Você consegue descobrir quanto tempo um processador com clock de 3,10GHz leva para
executar uma instrução?
Como veremos, é a unidade de controle que organiza e gera os sinais de

controle para que cada instrução seja executada na sequência correta e também
com os subciclos, ou subpassos como passaremos a nos referir, corretos.
Cada um dos subpassos tem sua importância no processo de execução

de um programa, dessa forma, eles são detalhados a seguir (STALLINGS, 2010).
Busca: nesse subpasso a unidade de controle busca pela instrução

fornecida na memória e a decodifica, deixando-a pronta para ser executada, a
seguir um registrador específico é incrementado de forma que no próximo ciclo
a instrução presente no próximo endereço de memória seja lida e decodificada.
Esse comportamento garante a sequência de execução das instruções, como se
fossem uma lista de tarefas. Lembra dessa analogia?
22
Execução: com a instrução pronta para ser executada, a unidade de controle

já sabe exatamente o que deve ser feito, com quais registradores fazer e para onde
mandar o resultado. Nesse subpasso, os sinais de controle são fornecidos para a
ULA e/ou os demais periféricos envolvidos.
Esses são os dois principais subpassos executados necessariamente a cada

instrução. Contudo, não podemos esquecer os outros dois, que apesar de não
acontecerem em todos os momentos, são importantes em alguns casos.
Indireto: em algumas situações o endereço presente na instrução não faz

referência direta ao endereço da memória que contém o operador. Nesses casos,
a instrução passa um ponteiro que aponta para o endereço de memória que está
o operador. Fazendo uma analogia é como se você pedisse para algum colega
lhe indicar para uma vaga. O entrevistador ficaria sabendo quem você é, mesmo
sem você falar nada para ele. Nessa situação, seu colega seria o ponteiro, ao passo
que o entrevistador seria a instrução e você o operador. Perceba que a instrução
é capaz de encontrar o operador, mas somente através do ponteiro. Pois bem, em
situações que um ponteiro é fornecido, o subpasso indireto deve ser executado
antes do subpasso de execução. Nele acontece a transformação de um endereço
indireto, endereçado através de um ponteiro, para um direto, que diz respeito
exatamente para onde o operador está.
Interrupção: como vimos anteriormente, os subpassos de busca e execução

acontecem de forma recorrente no microprocessador. Mas o que aconteceria se
durante a execução de uma soma um botão no teclado fosse pressionado? Como
o tratamento desses eventos não pode esperar, a unidade de controle pausa a
execução do que está sendo feito, salva o estado do processo atual nos registradores
e a interrupção começa a ser tratada. Após o tratamento da interrupção os dados
são recuperados do registrador e a execução é retomada. Essa abordagem garante
um processamento efetivo, uma vez que o processador não precisa aguardar que
uma interrupção aconteça para ela ser tratada (HENRIQUE, 2016).
4 REGISTRADORES
Não sei se você percebeu, mas falamos bastante de registradores nos
dois subtópicos anteriores, isso porque eles também desempenham um papel
fundamental no funcionamento de um processador. Para entendermos os
registradores, precisamos saber primeiramente que eles tratam de memórias, ou
seja, são capazes de armazenar bits durante o funcionamento do processador.
Em uma escala hierárquica, os registradores são as memórias mais compactas,
rápidas e caras que existem em um computador. Mas por que elas precisam ser
tão rápidas assim, você deve se perguntar. Pois bem, são os registradores que
guardam os dados que são processados em todo o microprocessador. Por exemplo,
os operadores de uma soma realizada pela ULA? São salvas em registradores.
O resultado dessa operação? Também. O byte que informa a próxima instrução
23
a ser lida pelo microprocessador? Também. Como essa informação é lida/

armazenada centenas ou milhares de vezes por segundo, os registradores devem
ser necessariamente feitos de memórias muito rápidas e confiáveis.
Como os registradores estão presentes na maioria das operações realizadas

por um microprocessador, e alguns são bem específicos, é difícil explicar um por
um. O que podemos fazer é dividi-los em grupos, e entender como cada um é
importante para o processador. A primeira distinção que podemos fazer é entre
os registradores que são visíveis ou não ao usuário (MACÊDO, 2012), como você
já deve ter deduzido, a primeira classe diz respeito a registradores que podem
ser acessados e alterados pelo usuário, ao passo que a segunda classe é interna
ao registrador. Podemos dividir ainda os registradores visíveis em duas classes:
os de uso geral e de uso específico, bem intuitivo, não? Os de uso geral como o
nome sugere podem ser utilizados pelo usuário como bem entender. Já os de
uso específico estão atrelados a uma determinada função do processador. Para
você entender de quanta especificidade estamos falando, vamos a um exemplo.
Dois registradores bastante utilizados pela ULA são os registradores MAR e
MBR. Sempre que a ULA vai executar uma operação que precisa acessar dados
na memória, o endereço dos dados é armazenado no registrador MAR, sendo
encontrado o operando no endereço especificado, ele é armazenado no registrador
MBR, sendo assim utilizado para realizar a operação.
NOTA
Durante o subpasso de busca conversamos sobre um “registrador específico”

que é incrementado a cada ciclo de execução, de modo que no próximo ciclo um novo
endereço de memória seja lido para buscar a próxima instrução a ser executada. Descubra
e pesquise a respeito desse registrador. Uma dica: O registrador IR recebe a instrução após
ela ser encontrada no endereço salvo nesse registrador.
5 BARRAMENTOS
Tente imaginar agora como todos esses dados vão para lá e para cá.
Como a ULA recebe os operandos, como a unidade de controle é informada que
um overflow aconteceu, ou como os dados são passados para os registradores.
Obviamente toda essa informação tem que ter um meio para ser transmitida, e
este meio são os barramentos. Os barramentos são linhas que interligam os mais
diversos dispositivos em um computador. Memórias, periféricos e placas de vídeo
são todas conectadas ao processador através de barramentos. Internamente, o
processador possui barramentos para endereços, para dados e para controle, que
interligam a ULA, a unidade de controle e os registradores.
24
6 SET DE INSTRUÇÕES
Falamos bastante anteriormente sobre as instruções. Como você deve ter
percebido as instruções são comandos que são interpretados pelo processador a
fim de executar uma determinada função, seja a divisão entre dois operandos, ou
mover o conteúdo de um registrador para outro. Assim, podemos dizer que as
instruções são a forma mais primitiva de um código de programação. Isso significa
que todo código que desenvolvermos utilizando linguagens de alto nível como C,
Phyton, Java, será convertido pelo compilador em forma de instruções que serão
interpretadas pelo processador. Para todos os efeitos, as linguagens de alto nível
são desenvolvidas para facilitar a vida do programador e aproximar mais ainda a
forma como nos comunicamos com a forma que de programar. Contudo, mesmo
programando sempre em alto nível, as instruções nos dizem muito sobre como
o microprocessador funciona, e são bastante importantes para você que está se
habituando com eles.
NOTA
Você sabe o que é um compilador? Os compiladores são programas que se

dedicam a traduzir o código escrito de uma determinada linguagem em outra. No texto,
o compilador que nos referimos traduz o código escrito em uma linguagem de alto nível
em linguagem Assembly. Aprenda mais sobre os compiladores em: https://www.dca.fee.
unicamp.br/cursos/EA876/apostila/HTML/node37.html.
6.1 ELEMENTOS DE UMA INSTRUÇÃO

Vamos iniciar vendo os elementos que compõem uma instrução.
Inicialmente, precisamos imaginar cada instrução como uma sequência de
bits. Essa sequência é dividida em campos e cada um deles tem um significado
lógico para o processador. Considere, por exemplo, uma instrução de 16 bits.
Nessa instrução, os quatro primeiros bits representam o opcode, ao passo que os
outros dois campos de seis bits representam os operandos. O formato da nossa
instrução com dois operandos pode ser visto na Figura 8. O opcode de uma
instrução representa basicamente o código da operação a ser realizada em binário,
podendo especificar operações aritméticas e lógicas, transferência de valores entre
registradores, dados de controle, entre outros. Dessa forma, o microprocessador
identifica a operação a ser executada através da leitura desse trecho de código.
Os outros dois campos são destinados para referenciar os operandos. Veja que
referenciar nesse caso significa dizer que os operandos podem ou não estão
exatamente presentes nesses campos. Quando não, eles são acessados através de
um registrador ou de um endereço de memória. Da mesma forma, podem ser
referenciados ainda nesse campo o operador de destino, ou em outras palavras,
o resultado da operação.
25
FIGURA 8 – FORMATO DE UMA INSTRUÇÃO COM DOIS OPERADORES
FONTE: O autor (2021)
A representação de uma instrução, como vimos, é completamente

compreensível para o processador, no entanto, muito complicada para o
programador. Imagine ter que lidar com sequências intermináveis de bits,
uma completa confusão! Vendo isso, o opcode das instruções é frequentemente
referenciado pelos programadores através de símbolos, conhecidos como
mnemônicos, que indicam qual operação está sendo executada. Já os operandos
são representados também de forma genérica através de números ou palavras.
Veja o exemplo de um código utilizando mnemônicos a seguir.
FIGURA 9 – EXEMPLO DE UM CÓDIGO EM LINGUAGEM DE MÁQUINA
O trecho de código mostrado move o valor presente no registrador A para

o registrador W, adiciona 10 (expresso em hexadecimal) a esse valor e o move
o resultado para o registrador B. Essa representação da instrução de máquina
em forma de mnemônicos, é na verdade a linguagem de programação conhecida
como Assembly. Esse nome é novo para você ou você já ouviu falar nele outras
vezes?
Se reescrito em linguagem C, por exemplo, o código anterior poderia ser

expresso como:
26
FIGURA 10 – CÓDIGO DA FIGURA 5 REESCRITO EM LINGUAGEM C
Bem mais simples, não acha? Com esses exemplos podemos ver a diferença
entre as linguagens de baixo e alto nível. Enquanto o Assembly foca muito mais
em mover dados para registradores, a linguagem de alto nível utiliza variáveis,
tornando a forma algébrica nesse último caso bem mais simples.
DICAS
Imagino que você esteja agora se perguntando sobre a importância do

Assembly para um engenheiro. De fato, existe uma boa discussão em torno desse assunto,
mas que não é o objetivo principal aqui. Dessa forma, a leitura do artigo pode ajudar
muito e instruir a respeito. Disponível em: https://www.profissionaisti.com.br/vale-a-pena-
aprender-o-bom-e-velho-assembly/.
6.2 TIPOS DE INSTRUÇÕES

Como vimos anteriormente, todo código em alto nível é traduzido em
linguagem de máquina por um compilador. Dessa forma, o set de instruções
do processador, que nada mais é que o conjunto de instruções possíveis, deve
conter instruções capazes de executar qualquer expressão em uma linguagem de
alto nível. Conforme afirma Stallings (2010), as instruções necessárias podem ser
categorizadas em: lógicos e aritméticas, armazenamento de dados, teste e desvio
e instruções de entrada e saída para o usuário. O Quadro 1 apresenta instruções
comuns utilizadas em processadores, divididos conforme essa categorização.
27
QUADRO 1 – INSTRUÇÕES COMUMS EM SET DE INSTRUÇÕES
Categoria Mnemônico Descrição

Add Calcula a soma entre operandos.
Subtract Calcula a subtração entre operandos.
Aritmética Incremente Incrementa o operando.
Decrement Decrementa o operando.
Negate Troca o sinal do operando.
AND Realiza o AND lógico entre dois operandos.
OR Realiza o OR lógico entre dois operandos.
Lógica NOT Realiza o NOT lógico.
Test Teste o operando em uma condição especificada.
Compare Faz a comparação lógica entre dois operandos.
Move Transfere valor da origem ao destino.
Store Transfere valor do processador para a memória.
Armazenamento Exchange Troco o valor da origem e do destino.
Set Transfere palavra de 1s para o destino.
Reset Transfere palavra de 0s para o destino.
Transfere a execução do programa para a
Jump instrução presente no endereço especificado.
Jump Testa uma determinada condição, caso seja
Teste/Desvio (condicional) satisfeita um Jump é executado.
Execute Executa o operando do endereço especificado.
Skip Salta para a próxima instrução.
Transfere dados de um periférico para o destino
Input especificado.
Entrada/Saída Transfere dados da origem especificada para o
Output periférico.
Transfere instruções para um periférico e inicia
Start sua operação.
Analisando as instruções anteriores, vemos que muito do que o

computador executa e faz já é contemplado por essas instruções. No entanto,
essa lista está longe de ser exaurível. Cada fabricante determina suas próprias
instruções cabendo a você estudar essas especificidades à medida que for tendo
essa necessidade.
6.3 NÚMERO DE ENDEREÇOS

Quando falamos em número de endereços, qual a primeira coisa que vem
a sua cabeça? Provavelmente, você associou ao número de endereços na memória,
o que não deixa de estar certo, mas aqui vamos ver a respeito da quantidade
de endereços contidos em cada instrução. Na Figura 8, por exemplo, utilizamos
dois endereços por instrução, perceba que os valores eram sempre transferidos
28
de um operador para o outro. Apesar de instruções com dois endereços serem

mais comuns, podem-se encontrar ainda processadores com uma e até com
três endereços. Com três endereços uma instrução é capaz de especificar dois
operadores e um destino para o resultado. Veja na Figura 11 como o código da
Figura 9 seria reescrito com três endereços.
FIGURA 11 – EXEMPLO DA FIGURA 8 REESCRITO EM INSTRUÇÕES COM TRÊS ENDEREÇOS
Perceba como reduzimos duas operações em apenas uma. Muito bom, não
é? Contudo, apesar da vantagem para o programador que faz mais escrevendo
menos, instruções com três endereços são instruções maiores, com mais campos, e
que requerem registradores maiores para armazenar e executar essas instruções.
Quanto maior o registrador, como você já deve imaginar, mais caro o processador.
6.4 TIPOS DE OPERANDOS

Analisando novamente os exemplos da Figura 9 e Figura 11, percebemos
que operamos com basicamente um número (0x0A), apesar das instruções
anteriores também referenciarem registradores, esses não são um tipo de dados.
Além dos números, temos ainda os caracteres, os dados lógicos e os endereços
como tipos de dados. Veremos um pouco mais a seguir sobre cada um deles,
pode parecer óbvio de início, mas o estudo particularizado deles vai ajudar muito
a sua jornada.
6.4.1 Números
O que você precisa entender aqui é que a representação dos números em
um computador vai mais além do que representar algarismos. Os números em
um computador são utilizados também para representar endereços, contadores
e o tamanho do campo das instruções. No entanto, ao contrário dos números
utilizados na matemática, que são um conjunto infinito, os números em um
computador têm um limite. Esse limite vai tanto com relação à magnitude dos
números inteiros como também a precisão (em termos práticos, a quantidade
29
de casas após a vírgula em números ponto flutuante) dos números do ponto

flutuante. Dessa forma, é bom ficar atento ao overflow e underflow. Explicado
isso, podemos extrair tópicos da explanação anterior a fim de facilitar a sua
compreensão.
Dois tipos de números estão presentes nos computadores:
- Números inteiros: são utilizados em endereços, contadores, tamanho

de campos de instrução e valores matemáticos, sendo limitados pela magnitude,
internamente são representados em valores binários, enquanto para o usuário são
apresentados valores decimais.
- Números ponto flutuante: são normalmente utilizados para representar

variáveis físicas como a temperatura em uma sala ou a velocidade de um veículo.
São os famosos números com valor após a vírgula. A precisão desses números,
assim como a magnitude, é limitada em computadores.
6.4.2 Dados lógicos

Como sabemos, os bits carregam uma natureza lógica por si só, sendo
que um bit 1 normalmente significa verdadeiro e um bit zero significa falso.
Assim, um conjunto de bits 1001, por exemplo, pode significar a representação
binária do número decimal 5, como também um conjunto de resultados lógicos
onde o primeiro e último resultado são verdadeiros e os demais são falsos. O
computador, naturalmente, é capaz de distinguir entre essas duas situações e
realizar operações lógicas com esses operandos.
6.4.3 Caracteres
Frequentemente há a necessidade de se representar textos, usando
sistemas de computação. Esses dados são complemente compreensíveis para o
usuário, mais difícil de serem representados pelo computador, basicamente pela
natureza binária dele. Contudo, como você está lendo esse texto possivelmente
em um computador, é de se imaginar que alguém já propôs uma solução para
isso. A solução veio através da representação de cada caractere por um conjunto
de bits. Na tabela ASCII (American Standard Code for Information Interchange), por
exemplo, cada caractere é representado por uma sequência única de 7 bits, sendo
possível até 128 caracteres diferentes.
30
6.5 ENDEREÇAMENTO
Estudando os elementos de instrução (Tópico 6.1), nós temos a tentação de
achar que o valor dos operadores pode ser diretamente informado na instrução,
ou até diretamente obtidos em um endereço de memória, contudo não são essas
as únicas formas de endereçamento.
O endereçamento diz respeito à forma como referenciamos o operador

em uma instrução. Indiretamente estudamos ao longo desse tópico várias
formas de endereçamento: como quando estudamos o ciclo indireto, ou quando
referenciamos diretamente um valor em hexadecimal nos exemplos da Figura
9 e Figura 11. Vamos agora apresentar os demais casos e consolidar esse
conhecimento. Segundo Monteiro (2007) são seis os tipos de endereçamento mais
comuns desenvolvidos para processadores:
• Imediato.
• Imediato.
• Direto.
• Indireto
• Por registrador.
• Indexado.
• Base mais deslocamento.
Vamos analisar cada um desses modos a seguir.
6.5.1 Imediato
Esse é o modo de endereçamento mais simples que veremos. Na Figura 9,
quando adicionamos 0x0A ao valor de W, estávamos endereçando diretamente
o valor 0x0A como operador. Desse modo, no endereçamento imediato sempre
apresentamos diretamente o operando na instrução. Apesar da praticidade, o valor
que endereçamos (operando) deve sempre ser menor que o valor máximo para
o operador, ou seja, caso tenhamos 6 bits de operador na instrução, é impossível
endereçar no modo imediato um valor com 8 bits. A vantagem desse método,
como já vimos, é que um subpasso na execução da instrução é economizado,
sendo o tipo de endereçamento mais rápido. Dessa forma, podemos utilizá-lo
na inicialização de contadores e na maioria das operações com números inteiros.
6.5.2 Direto
No modo de endereçamento direto, um endereço da memória é
referenciado no campo do operador. Como você deve imaginar, esse endereço
diz respeito ao local onde o processador deve procurar pelo operando. Dessa
forma, podemos lidar com números binário bem maiores, uma vez que a memória
31
é bem mais ampla que o campo do operador. Contudo, ainda temos aqui uma
limitação em relação ao endereço que pode ser referenciado no campo operador.
Com o nosso operador de 6 bits, por exemplo, só poderíamos referenciar até 63
endereços de memória, o que é muito pouco se considerarmos a quantidade de
endereços de memória nos processadores modernos.
6.5.3 Indireto
Quando o endereço do operando é muito maior que o campo reservado
para o operador, devemos utilizar o modo de endereçamento indireto. Nesse
modo, é passado ao operador um endereço de memória, que por sua vez se
refere a outro endereço de memória, onde o operando está armazenado. O
endereço que se refere, ou “aponta” para onde o operando está é conhecido como
ponteiro. Como vimos, nesse caso temos a necessidade do subpasso indireto, e
consequentemente, maior demora para a execução da instrução.
6.5.4 Por registrador

No endereçamento por registrador, em vez de passarmos ao operador
um endereço da memória, passamos um registrador. Como os registradores
são memórias mais rápidas, existe um ganho de velocidade na execução da
instrução. Contudo, como vimos no subtópico 4, apenas alguns registradores
estão disponíveis ao usuário, sendo necessário um uso eficiente deles.
O endereçamento por registrador pode ser usado de forma direta,

referenciando o registrador no campo do operador, ou de forma indireta, no qual
o registrador armazena o endereço que aponta para o operando.
6.5.5 Indexado
A fim de entendermos melhor o modo indexado, se faz interessante
estabelecermos uma analogia. Imagine as vagas de um estacionamento de um
shopping center. Devido à quantidade de carros, esse estacionamento foi divido
em blocos indexados como A, B, C e D. Dessa forma, cada carro estacionado é
identificado através da identificação do bloco, e a posição da vaga. Sendo A0 a
primeira vaga do estacionamento A, por exemplo. Essa forma é especialmente
útil pois em vez de identificarmos, a última vaga como 180 identificamos como
D60, entendido? Pois bem, vamos trazer esse exemplo para a realidade dos
computadores.
Da mesma forma que no nosso estacionamento, podemos dividir

a memória em trechos, fazendo com que os endereços subsequentes sejam
incrementos do endereço inicial. Assim, em vez de passar o endereço completo,
32
podemos simplesmente passar uma referência em relação ao endereço inicial.

Tratando-se de endereçamento, esse modo é conhecido como modo indexado.
Nele, o endereço inicial é armazenado no campo do operador e um registrador é
utilizado para armazenar o incremento necessário. Desse modo, durante operações
de iteração (operações sucessivas), em vez de referenciar cada endereço, podemos
simplesmente indicar o endereço inicial e ir gerando os incrementos que forem
necessários no registrador.
6.5.6 Base mais deslocamento

No endereçamento por base mais deslocamento acontece exatamente o
oposto do que vimos no modo indexado, ou seja, em vez do endereço inicial,
aqui chamado de base, ser armazenado no campo do operador, ele é armazenado
em um registrador, enquanto o deslocamento fica salvo no operador. Em termos
práticos, enquanto no modo indexado existe um incremento do endereço inicial,
aqui existe um deslocamento em relação ao endereço base.
7 AS ARQUITETURAS RISC E CISC

À medida que as linguagens de alto nível foram progredindo, mais
distantes foram ficando os comandos da linguagem de máquina como conhecemos.
Essa grande diferença gerou bastante dificuldade para os compiladores antigos,
que tinham que traduzir uma única instrução em linguagem de alto nível para
várias em linguagem de máquina (MONTEIRO, 2007). Essa distância entre a
forma como máquina e homem se comunicavam levou a necessidade de rever
o conjunto de instruções que eram utilizadas nos processadores. A solução na
época, foi aumentar o número de instruções, criando instruções mais complexas e
mais específicas. A ideia era aproximar a linguagem de máquina da linguagem de
alto nível, possibilitando assim uma tradução pelos compiladores mais compacta.
Com o tempo, os microprocessadores que possuíam uma grande quantidade
de instruções complexas ficaram conhecidos como Complex Instruction Set
Computers, ou processadores CISC, como passaremos a chamar.
Tudo bem, você já sabe que os processadores com arquitetura CISC

possuem um set de instruções maiores, mas vamos analisar um pouco das
características específicas dessa arquitetura (MONTEIRO, 2007).
A primeira característica relacionada é a presença de modos de transfe-

rência entre registradores, registrador para memória e memória para registrador.
Como existem poucos registradores, a maioria dos acessos é feita na memória,
havendo assim a necessidade da transferência entre a memória e o registrador.
33
A segunda característica é o tempo de execução das instruções. Como

em geral as instruções são mais complexas, muitas vezes são necessários vários
ciclos para completar a execução de uma instrução. Em geral, os processadores
da arquitetura CISC também possuem mais modos de endereçamento para a
memória, o que traz a necessidade de mais ciclos de máquina.
Apesar da proposta de aproximar a linguagem de máquina e as linguagens

de alto nível pareça a solução ideal em um primeiro momento, houve grandes
críticas ou pontos problemáticos, por assim dizer, citadas principalmente
pelos criadores da arquitetura RISC (PATTERSON; DITZEL, 1980). O primeiro
contraponto da arquitetura CISC diz respeito ao tamanho das instruções. Apesar
da arquitetura prever a expressão de um programa em poucas instruções, cada
instrução ocupa um grande espaço de memória, não sendo necessariamente assim
uma economia de recursos. Podemos justificar essa afirmação simplesmente
olhando para o opcode da instrução, como existem mais instruções, um opcode
maior é necessário, levando necessariamente a instruções maiores. Além disso,
a redução no uso da memória não é mais uma grande vantagem como era
antigamente, principalmente devido ao barateamento das mesmas (STALLINGS,
2010).
Com as críticas apontadas por Patterson e Ditzel (1980), uma nova

arquitetura foi proposta, desta vez com um número reduzido de instruções. Essa
arquitetura ficou conhecida como Reduced Instruction Set Computer, ou RISC,
como você vai ver por aí a fora. A arquitetura RISC trocou as instruções complexas
da arquitetura CISC, por instruções simples de formato fixo. Dito isso, vamos
analisar um pouco melhor as características da arquitetura RISC (STALLINGS,
2010).
Uma característica marcante da arquitetura RISC é a forte presença de

registradores. Por conta disso, a maioria das operações são entre registradores,
havendo pouca necessidade de acessar a memória. Dessa forma, os operandos
permanecem a maior parte do tempo em memória de alta velocidade, deixando o
armazenamento, e a operação mais rápida, uma vez que não há a necessidade de
realizar acessos frequentes à memória. Outro fator que contribui com a execução
das instruções é o modo de endereçamento, que nas arquiteturas RISC são
simples, sem subpassos adicionais.
Além de ter o formato fixo, ou seja, cada instrução possuir a mesma

quantidade de bytes, as instruções na arquitetura RISC são executadas em
um único ciclo de máquina, o que garante uma melhor previsibilidade do
funcionamento do processador.
Você deve se perguntar agora qual seria a melhor arquitetura ou até

mesmo colocando um pouco mais de prestígio na arquitetura RISC, mas o fato é
que nem sempre existem melhor ou pior e sim o melhor para uma determinada
aplicação. Dessa forma, tanto Stallings (2010) quanto Monteiro (2007) não chegam
34
a um consenso a respeito da melhor arquitetura, ao invés disso, são apresentadas

por eles tendências de utilização das melhores características de cada arquitetura
em um processador com arquitetura híbrida.
De modo geral, o fato de um processador ser conhecido como RISC ou

CISC, já adianta muito a respeito do seu modo de funcionamento, e do que
esperar da sua arquitetura. No próximo tópico, você vai estudar em detalhes o
microcontrolador Atmega328, que compõe a placa Arduino Uno. Sabendo que
esses microcontroladores possuem uma arquitetura RISC, já podemos esperar um
número reduzido de instruções e todas as outras características que estudamos
aqui nesse tópico.
8 AS ARQUITETURAS VON NEUMANN E HARVARD

Pode parecer inusitado, mas os primeiros computadores já possuíam
arquiteturas que descreviam a sua funcionalidade. O ENIC, por exemplo, foi
implementado utilizando a arquitetura proposta pelo famoso físico e matemático
John von Neumann, enquanto o Harvard Mark I, desenvolvido aproximadamente
na mesma época, utilizava uma arquitetura diferente, que ficou conhecida
posteriormente como Harvard. Você deve imaginar que em algum ponto
essas arquiteturas foram trocadas por outras mais modernas, ou com melhor
desempenho, mas não. Tanto a arquitetura Harvard como a Von Neumann ainda
são utilizadas nos computadores modernos.
Diferente das arquiteturas CISC e RISC, que vimos anteriormente e que

dizem respeito à quantidade de instrução de um processador, as arquiteturas
Harvard e Von Neumann dizem sobre como o processador está organizado.
Veremos a seguir como cada uma funciona.
A arquitetura criada por John Von Neumman se baseia no armazenamento

de instruções e dados em uma mesma memória, sendo em geral mais simples
de ser implementada e mais barata se comparada com a Harvard (KHILLAR,
2018). No entanto, nesse formato, a execução de uma instrução leva dois ciclos
de máquina para completar a execução, uma vez que, no primeiro ciclo a própria
instrução é obtida, e no segundo os dados são obtidos. Já na arquitetura Harvard,
a memória de programa (onde as instruções são obtidas) é separada fisicamente
da memória de dados, sendo possível o acesso simultâneo e a execução de uma
instrução em um único ciclo de máquina. O diagrama de blocos da arquitetura
Harvard e Von Neumman pode ser visto na Figura 12.
35
FIGURA 12 – DIAGRAMA DE BLOCOS DAS ARQUITETURAS HARVARD E VON NEUMANN
Assim como nas arquiteturas CISC e RISC, aqui também não é possível
indicar qual seria a melhor arquitetura de dados, uma vez que temos pontos
positivos e negativos em cada uma das arquiteturas. Enquanto a arquitetura Von
Neumann possui uma simplicidade de implementação menor, principalmente da
unidade de controle e dos barramentos, a arquitetura Harvard é mais eficiente na
execução das instruções. Dessa forma, a arquitetura Von Neumann é empregada,
na maior parte do tempo em computadores de uso pessoal, como desktops e
notebooks, e a arquitetura Harvard em microcontroladores e DSP (Digital Signal
Processing) (KHILLAR, 2018).
36
RESUMO DO TÓPICO 2
• As arquiteturas dos computadores podem ser divididas em blocos: CPU,

barramentos, periféricos e memória principal, sendo a CPU a parte responsável
pela lógica e controle do computador.
• Dentro da CPU, a ULA é responsável por todo o processamento lógico e

aritmético do processador, recebendo para isso instruções da unidade de
controle e os operandos através de registradores. Da mesma forma, o resultado
é entregue através de registradores, podendo ou não ser gerado uma flag que
indica se houve algum erro durante a operação.
• A Unidade de Controle é responsável por gerar os sinais para a execução

correta das instruções no processamento.
• Que cada ciclo de instrução é composto de subpassos, sendo o subpasso de

busca e execução os únicos presentes em todos os ciclos. Já os subpassos
indireto e interrupção dependem do modo de endereçamento e da presença
de interrupções para tratamento, respectivamente.
• O processador se comunica através de instruções, que são formadas

basicamente pelo opcode e pelos operadores. Cada instrução é formada por
uma sequência de zeros e uns, entendível pelo processador, mas dificilmente
interpretada pelo ser humano.
• Cada processador é composto por um conjunto de instruções, que devem ser

capazes de executar todas as operações necessárias em um processador.
• Os operandos de uma instrução podem ser expressos através de vários tipos,

dependendo da necessidade do programador. Entre os estudados estão os
números, os caracteres e os dados lógicos.
• Os operandos podem ser endereçados de várias formas, dependendo da

necessidade de acordo com o tipo de endereçamento, a execução da instrução
pode ser realizada mais rapidamente ou não, dependendo por exemplo, da
necessidade de acesso a memória ou não.
• Existem dois tipos de arquiteturas associadas à quantidade de instruções do

processador. Processadores com arquitetura CISC possuem instruções mais
complexas, sem tamanho fixo, e que muitas vezes necessitam de vários ciclos
de máquina para serem concluídos. Já os processadores com arquitetura RISC
possuem um conjunto de instruções menor, todas com tamanho fixo com
tempo de execução limitado pelo ciclo da máquina.
37
• Apesar de já estarem presentes nos primeiros computadores, as arquiteturas
Von Neumann e Harvard são utilizadas até hoje dependendo da aplicação. A
principal diferença entre elas está na presença de um barramento único para
dados e instruções na arquitetura Von Neumann, enquanto na arquitetura
Harvard um barramento duplo é observado.
38
AUTOATIVIDADE
1 Os processadores modernos estão por toda a parte, desde os computadores

e celulares até nas bombas de gasolina. A arquitetura desses processadores
pode ser dividida em blocos que facilitam o seu estudo de forma geral.
Acerca da arquitetura de um processador, classifique V para as sentenças
verdadeiras e F para as falsas:
( ) A ULA é capaz de gerar sinais para a Unidade de Controle indicando

que houve alguma anormalidade na execução de uma operação lógica/
aritmética.
( ) Apesar da Unidade de Controle gerar os sinais que garantem a correta
execução de uma instrução, ela não tem a capacidade de tratar eventos
que acontecem de forma repentina no processador.
( ) Os barramentos executam papel fundamental em processador transferindo
dados entre a ALU e a Unidade de Controle.
( ) Os registradores são memórias de alta confiabilidade capazes de
armazenar dados em altas velocidades. A única desvantagem é o preço
alto desse tipo de memória.

a) ( ) V – V – F – F.
b) ( ) F – F – V – V.
c) ( ) V – F – F – V.
d) ( ) F – V – V – F.
2 Sabendo da importância dos registradores para o processador e da

diversidade deles, explique como eles são agrupados e apresente um
exemplo para cada tipo apresentado.
3 Apesar de não ser mais utilizada pela maioria dos programadores,

a linguagem Assembly ainda é útil para o entendimento de como o
processador interpreta as instruções. Dessa forma, crie um programa
simples que transfira 0x0A (hexadecimal) para o registrador A, decremente
esse valor e em seguida transfira para o registrador B, acrescentando 2, em
decimal.
4 Cada instrução é formada basicamente por um opcode, que indica ao

processador o tipo de instrução e por operandos que podem ser endereçados
de diversas forma. Sobre os tipos de endereçamento, associe os itens,
utilizando o código a seguir:
I- Imediato
II- Direto
III- Indireto
39
IV- Por registrador
V- Indexado
( ) O operando é endereçado diretamente no campo do operador.

( ) O operando é endereçado através de um endereço base mais um
incremento.
( ) O operando é endereçado através de um endereço de memória.
( ) O operando é endereçado através de um ponteiro que aponta para onde
o mesmo está.
( ) O operando é endereçado através de um registrador.

a) ( ) I – IV – II – IV – III.
b) ( ) I – V – II – III – IV.
c) ( ) V – I – II – III – IV.
d) ( ) II – I – III – IV – V.
5 As arquiteturas Harvard e Von Neumann surgiram para compor os

computadores Mark I e o famoso ENIAC, respectivamente. Apesar serem
utilizadas até hoje nos computadores modernos, essas arquiteturas propõem
construções diferentes. Assinale a alternativa que apresenta a alternativa
CORRETA:
a) ( ) A arquitetura Harvard possui uma memória menor que a arquitetura

Von Neumann, o que garante maior rapidez para essa última.
b) ( ) A arquitetura Harvard é conhecida por ser de mais simples
implementação que a arquitetura Von Neumann.
c) ( ) A respeito da construção a arquitetura Von Neumann propõe um único
barramento para dados e instruções enquanto a arquitetura Harvard
propõe separá-los em barramentos independentes.
d) ( ) A respeito da construção a arquitetura Von Neumann propõe um
barramento único para dados e outro para instruções enquanto a
arquitetura Harvard propõe unificá-los em um único barramento, o
que pode levar a uma demora na execução.
40
O MICROCONTROLADOR ATMEGA328
1 INTRODUÇÃO
A necessidade por componentes eletrônicos pequenos e versáteis fez
com que os microcontroladores se destacassem no desenvolvimento de projetos.
Principalmente quando falamos de sistemas embarcados, robótica e até em
aplicações médicas os microcontroladores são unanimidade, por possuírem
agregados todos os componentes necessários para o desenvolvimento dessas
aplicações, tais como, microprocessador, memória RAM e ROM, temporizadores
e circuitos de clock. A grande maioria possui ainda funcionalidades como:
memórias EEPROM e flash, conversores AD, timers, controle PWM, e RTC.
Com o tempo, os microcontroladores passaram a integrar ainda as placas

de desenvolvimento, que, além de já possuírem um microcontrolador nativo,
oferecem ao usuário forma facilitada de programá-lo, normalmente através de
uma porta USB, acesso facilitado aos pinos de entrada e saída, e outros recursos
como osciladores externos e reguladores de tensão. Entre as diversas placas de
desenvolvimento já citamos, utilizaremos o Arduino para continuar os nossos
estudos e adentrar esse universo fascinante que é o desenvolvimento de sistemas
microcontrolados. O motivo de escolher o Arduino é simples: toda a estrutura
foi desenvolvida para você, acadêmico, experimentar, criar e dar os primeiros
passos nessa área. Ainda, o Arduino possui uma comunidade presente, que pode
te ajudar bastante em assuntos além do escopo desse livro.
Mesmo em um ambiente de desenvolvimento onde uma linguagem de alto

nível é utilizada, se faz necessário conhecermos a arquitetura do microcontrolador
que estamos utilizando. De posse desse conhecimento, temos na palma da mão
os limites do microcontrolador e seremos bem mais capazes de lidar com erros
e outras situações peculiares que temos durante o desenvolvimento de projeto.
Dessa forma, durante esse tópico, usaremos os conhecimentos adquiridos no
Tópico 2 para analisar a arquitetura do microcontrolador Atmega328, presente na
placa de desenvolvimento Arduino Uno. O Atmega328, além de representar bem
os dispositivos megaAVR da família AVR, é um dos microcontroladores mais
utilizados, sendo indicado para a maioria das aplicações.
O intuito desse tópico é levar o conhecimento que adquirimos

anteriormente para perto dos microcontroladores, que será o assunto do restante
desse livro. Iremos ver como os registradores são utilizados notmega328, qual as
principais interrupções, entre outros assuntos. Dessa forma, a leitura deste tópico
41
está condicionada ao conhecimento prévio da maioria dos conceitos presentes no

Tópico 2, que não serão revisados aqui. Assim, caso você sinta alguma dificuldade
ou falta de algum conceito, indicamos uma revisão do Tópico 2.
2 FAMILIA AVR
O conceito de família em microprocessadores não é recente. Desde os
primórdios, os dispositivos de uma mesma família possuíam características
em comum e diferiam na maior parte do tempo em recursos adicionais como:
memória ou capacidade de processamento, ou mais recentemente em recursos
auxiliares, como: presença de módulo de comunicação WiFi, Bluetooth ou display
de LED. Dessa forma, o estudo de um indivíduo facilita bastante o conhecimento
da família como um todo.
O microcontrolador Atmega328, que vamos estudar, faz parte da família

AVR. Segundo Lima e Villaça (2012), os primeiros microcontroladores AVR foram
desenvolvidos pela fabricante Atmel em meados de 1997. Em 2016, a empresa foi
vendida para a Microchip que deu continuidade à família AVR. Falando um pouco
sobre os detalhes construtivos, os microcontroladores AVR são dispositivos de 8
bits que possuem uma arquitetura Harvard com um set de instruções reduzidos
(RISC). Dessa forma, todas as instruções possuem tamanho fixo e a grande
maioria é executada em até um ciclo de clock.
A seguir são apresentados os principais “membros” da família AVR

(LIMA; VILLAÇA, 2012). A intenção aqui é que você, acadêmico, tenha uma noção
geral da família e que possa estabelecer uma comparação entre os dispositivos
megaAVR, ao qual o Atmega328 está incluído, e os demais dispositivos, estando
assim preparado para futuramente escolher a melhor opção para cada aplicação.
• tinyAVR – são microcontroladores de uso de geral otimizados para aplicações

que exigem bom desempenho e encapsulamentos pequenos. Os novos
dispositivos Attiny foram lançados em 2017 pela Microchip e possuem
memória flash de 16 KB, 2KB de memória SRAM e 256B EEPROM, além de
operarem em tensões entre 1,8V a 5,5V (MICROCHIP, 2017).
• megaAVR – são microcontroladores com mais recursos que o tinyAVR,
possuindo memórias flash de até 256KB e 8KB de memória SRAM. Em geral,
possuem encapsulamentos maiores com 28 a 100 pinos (MICROCHIP, 2017).
• XMEGA – são os microcontroladores de maior desempenho da família,
possuindo memórias flash de até 384KB e SRAM de até 32KB. Os Xmega
alcançam 32 MHz de processamento, e possuem maior oferta de conversores
AD, canais PWM e contadores.
A Figura 13 apresenta a comparação de todos os dispositivos em produção

pela Microchip nessas três categorias, em termos de capacidade de memória e
ciclo de trabalho. A referência apresentada na Figura 13 pode ser consultada
42
TÓPICO 3 — O MICROCONTROLADOR ATMEGA328
para a avaliação desses dispositivos em termos de recursos como conversores

AD, geradores PWM, contadores, protocolos de comunicação ou até mesmo em
termos de criptográfica de dados.
FIGURA 13 – GUIA PARA COMPARAÇÃO DE TODOS OS DIPOSITIVOS EM PRODUÇÃO DA

FAMILIA AVR
FONTE: Adaptado de <https://www.microchip.com/content/dam/mchp/documents/MCU08/

ProductDocuments/Brochures/30010135E.pdf>. Acesso em: 6 abr. 2021.

3 ARQUITETURA
Agora que temos uma visão geral da família AVR, vamos nos aprofundar
no estudo do microcontrolador Atmega328, presente na placa de desenvolvimento
Arduino Uno, conforme já comentamos. A melhor forma de estudar qualquer
43
microcontrolador, é consultar o datasheet (folha de dados, do inglês) desse

dispositivo. O datasheet é um documento publicado pelo fabricante que
apresenta os detalhes construtivos, limites elétricos, tempos de atuação, e no caso
dos microcontroladores: a arquitetura, o conjunto de instruções e os registradores
presentes. Dessa forma, nos basearemos aqui no datasheet do Atmega328 para
estudá-lo em detalhes (MICROCHIP, 2020).
Assim como os demais dispositivos da família, o Atmega328 é um

microcontrolador 8 bits de baixo consumo com arquitetura Harvard. O
microcontrolador possui uma arquitetura RISC avançada, que permite produzir
códigos mais compactos ao mesmo tempo que possibilita um conjunto de
instruções não tão reduzido. São utilizadas 131 instruções, onde a execução
da maioria delas é feita em até um ciclo de máquina. Quanto à capacidade de
processamento, o Atmega328 é capaz executar até um milhão de instruções por
segundo por mega-hertz. Na prática, isso significa que operando a 20 MHz (clock
limite do dispositivo) é possível processar 20 milhões de instruções por segundo.
Um número bem expressivo, não acha? Principalmente para um dispositivo que
possui pouco menos de 3,5 cm de comprimento e 1 cm de largura. Segundo a
Microchip (2020), a arquitetura utilizada é até dez vezes mais rápida que a
arquitetura CISC tradicional para microcontroladores.
Quanto à disponibilidade de memória, o Atmega328 possui especificamente

32 KB de memória flash para armazenagem de programa, 1 KB de EEPROM
e 2 KB de SRAM. Apesar de já termos visto os termos EEPROM, SRAM e até
mesmo memória flash em outros momentos, o momento mais conveniente para
essa explicação será quando estivermos tratando da memória de programa.
Por enquanto, basta saber que são tipos diferentes de memória utilizadas em
aplicações diferentes nos microcontroladores. O Atmega328 conta ainda com 32
registradores de propósito geral que são diretamente conectados a ULA.
Outra informação que não podemos deixar de fora do nosso estudo é

arquitetura da CPU do microcontrolador. Na Figura 14 vemos o diagrama de
blocos da CPU do Atmega328, apesar dos termos estarem em inglês, faremos uma
análise termo a termo, a seguir.
• Data Bus 8 - bit: trata-se do barramento utilizado para o fluxo da informação

dentro do processador.
• General Propose Registers: são os registradores de propósito geral, que
conforme vimos anteriormente estão conectados diretamente a ULA.
• Program Counter: registrador responsável por armazenar o endereço na
memória flash da próxima instrução a ser executa pelo microcontrolador.
• Status and Control: são os registradores responsáveis por indicar o resultado
das operações que ocorrem dentro do microcontrolador.
• I/O Lines: se comunicam com os pinos do microcontrolador podendo receber
ou enviar dados através deles.
• I/O Module: módulos de comunicação com dispositivos internos, o Atmega328
possui três o PORTB, PORTC e PORTD como veremos mais à frente.
44
• Analog Comparator: módulo de comparação analógica, através dele é

possível comparar dois sinais analógicos, como temperatura, tensão, corrente
ou outros.
• Watchdog Timer: contador adicional presente na grande maioria dos
microcontroladores, é responsável por retornar o dispositivo do modo de baixa
energia ou para limitar o tempo que o dispositivo passa em determinadas
operações, evitando que em caso de mal funcionamento a operação seja
executada indefinidamente.
• SPI Unit: permite a transferência serial síncrona em alta velocidade entre o
Atmega328 e outros dispositivos como comunicação serial. Tem a possibilidade
de atuar como mestre, controlando outros dispositivos ou como escravo, onde
o controle se inverte.
• Interrupt Unit: responsável por configurar e tratar as interrupções que
ocorrem no microcontrolador. Veremos mais a respeito nas próximas seções.
FIGURA 14 – DIAGRAMA DE BLOCOS DA CPU PRESENTE NO ATMEGA328
FONTE: <https://ww1.microchip.com/downloads/en/DeviceDoc/ATmega48A-PA-88A-PA-168A-
-PA-328-P-DS-DS40002061B.pdf>. Acesso em: 8 abr. 2021.
45
4 MEMÓRIAS DE PROGRAMA
Como já sabemos, existem tipos diferentes de memórias em um
microcontrolador. Termos como EEPROM, flash, SRAM podem causar uma certa
confusão, então, vamos começar apresentando essas definições.
Dentro de um processador as memórias podem ser utilizadas

para armazenagem tanto de dados como instruções. Atualmente, para o
armazenamento de dados em microcontroladores são utilizadas as memórias
SRAM (Static RAM), que armazenam os dados enquanto houver alimentação,
ou seja, a partir do momento que o dispositivo é desligado existe a perda da
informação nessas memórias. Já as memórias utilizadas para salvar instruções
são duráveis não havendo a perda de informação após o desligamento. Hoje são
presentes dois tipos dessas memórias nos microcontroladores: as memórias flash,
que são memórias regraváveis eletricamente, de baixo custo e de alta velocidade
de leitura, sendo empregadas no armazenamento de instruções; e a memória
EEPROM, que assim como a memória flash é apagável, mas possui um número
limitado de gravações (FERRARI, s. d.). A memória EEPROM é normalmente
utilizada para a armazenagem de dados permanentes ou pouco passíveis de
alteração. Imagine que seja necessário armazenar o último estado de um LED
antes do desligamento, de forma que ao iniciar novamente o microcontrolador,
ele já inicie com o estado salvo. Nessa situação poderíamos utilizar a memória
EEPROM para o armazenamento dessa variável. Apesar da EEPROM permitir
menos ciclos de gravação que a memória flash, nas memórias modernas ainda é
possível realizar em torno de 100.000 gravações em toda sua vida útil.
NTE
INTERESSA
A memória EEPROM é a sucessora de uma linha de memórias não voláteis.

Uma das primeiras memórias que surgiu foi a PROM, onde os dados só podiam ser gravados
uma única vez através da aplicação de tensões bem acima da operação normal. Com o
tempo surgiram as memórias EPROM que entre outras vantagens tinham a capacidade
de reprogramação através de uma luz ultravioleta, contudo para realizar o processo era
necessário enviar o chip ao fabricante, processo que demorava dias (ALECRIM, 2011).
Imagina errar uma linha de código nessas memórias? Com as memórias EEPROM tudo
ficou mais simples, uma vez que não é preciso nem remover o chip do circuito para fazer
a regravação.
De posse dessa definição, nós podemos investigar um pouco mais a fundo

a memória de programa no Atmega328.
46
O Atmega328, como vimos, possui 32 KB de memória flash. Como são

empregadas normalmente instruções de 16 bits (2 bytes), é possível endereçar até
16384 instruções, ou para se ter uma comparação melhor: 16384 linhas de código
Assembly, uma vez que cada instrução em Assembly representa uma instrução
de máquina, lembra? Contudo, parte dessas linhas são utilizadas para armazenar
o bootloader do microcontrolador. Você consegue imaginar a utilidade dele?
De forma simples, o bootloader é um programa que grava outro programa. O
bootloader é responsável por preparar o hardware do microcontrolador para
receber a nova programação feita por você, e gravá-la na memória de programa,
sem a necessidade de um gravador externo. Dessa forma, a memória de programa
do Atmega328 pode ser dividida na seção de aplicação, que efetivamente armazena
o programa escrito pelo programador e o bootloader. Ambas as seções são
apresentadas na Figura 15, que apresenta a memória de programa do Atmega328.
Cada uma das instruções é endereçada pelo registrador PC (Program

Counter) que no Atmega328 possui 14bits, necessários para armazenar o endereço
de uma das 16384 instruções possíveis a cada ciclo de instrução.
A memória EEPROM de 1KB, presente no dispositivo não é utilizada

para o armazenamento das instruções em si, mas pode ser utilizada para o
armazenamento de variáveis de programa. Os valores armazenados nesse
tipo de memória podem ser lidos ou escritos bit a bit pelo programador, mas
devem respeitar o limite de gravações, que no caso do Atmega328 é 100.000
ciclos (MICROCHIP, 2020). Assim como a memória flash, a memória EEPROM
é acessada através de registradores específicos, que endereçam, controlam e
armazenam os valores a serem lidos ou escritos nela.
FIGURA 15 – MEMÓRIA DE PROGRAMA DO ATMEGA328
FONTE: Adaptado de <encurtador.com.br/oABN1>. Acesso em: 14 abr. 2021.
47
5 MEMÓRIA DE DADOS
Partindo da definição que vimos na seção anterior, vamos explorar a
memória SRAM presente no Atmega328. No dispositivo, os 2 KB de memória SRAM
presentes são divididos entre os 32 registradores de uso geral, 64 registradores
para dispositivos externos, e como o Atmega328 possui uma capacidade de
periféricos maior que esses 64 registradores seriam capazes de suportar, mais
160 registradores adicionais são destinados para esse fim. As 2048 localizações
de memória restantes endereçam os dados temporários no microcontrolador. A
Figura 16 apresenta a divisão da memória SRAM conforme descrevemos aqui.
Aqui é interessante explorarmos também um pouco mais o uso da

memória interna. A maioria dos microcontroladores, incluindo o Atmega328,
utilizam uma parte da memória interna para implementar o que se chama de
software stack. Essa área é alocada para armazenar dados temporários em forma
de pilha, ou seja, os dados que chegam vão sendo armazenados do maior endereço
para o menor (MICROCHIP, 2020), formando literalmente uma espécie de pilha,
daí a denominação stack. Por último o termo software indica que essa stack é
implementada via software, ou seja, não existe um hardware específico para a
stack e ele é definido em parte da memória interna da memória SRAM.
FIGURA 16 – DIVISÃO DA MEMÓRIA SRAM NO ATMEGA328
FONTE: Adaptado de <encurtador.com.br/pGIKU>. Acesso em: 14 abr. 2021.
Existe ainda um registrador específico para realizar o acesso da stack,

chamado de stack pointer (ponteira da pilha, em uma tradução literal). O stack
pointer é responsável por armazenar o endereço da pilha em que a próxima
variável será armazenada (ELPROCUS, s.d.). Basicamente, esse registrador inicia
com o maior endereço da pilha e vai sendo decrementado em um sempre que uma
nova variável deve ser armazenada. De modo inverso, ao retirar uma variável da
pilha o stack pointer é incrementado e o valor do endereço é lido. Vale ressaltar
que o armazenamento decrescente da stack, ou seja, do maior endereço para o
menor, como vimos, é válido para o Atmega328 mas pode não ser para outros
microcontroladores.
48
A respeito ainda da memória SRAM podemos destacar a presença dos

registradores de uso geral e os registradores responsáveis pela interface com
os dispositivos externos. Contudo, pela diversidade de registradores e da
importância de alguns deles para o microcontrolador em estudo, reservaremos o
próximo tópico para estudá-lo.
6 REGISTRADORES
Como você deve se lembrar, estudamos anteriormente os registradores
como memórias muito rápidas que são responsáveis pelo armazenamento de
variáveis dentro do processador. Essa informação não deixa de ser verdade, mas
acontece que nos microcontroladores os registradores são salvos também na
memória SRAM, sendo eles, na verdade, trechos dela. Dessa forma, cada trecho
da memória SRAM é divido em trechos onde são implementados registradores.
Por exemplo, nominalmente, o intervalo de memória que vai do 0x0000 ao 0x001F
(lembre-se, endereços de memória sempre em hexadecimal) na memória SRAM
do Atmega328 é reservada para os 32 registradores de uso geral, que como o
nome sugere, podem armazenar quaisquer valores, desde que caibam no espaço
definido.
No entanto, nem todo registrador é de uso geral, e alguns possuem

utilidades bem específicas dentro do microcontrolador. Como assim utilidades?
Bem, podemos dizer que de acordo com o valor salvo dentro desse registrador o
microcontrolador pode tomar uma ou outra decisão. Um exemplo bem simples
é o registrador SPH e SPL, que em uma tradução literal significam Stack Pointer
High e Stack Pointer Low, ou seja, são a parte mais elevada e mais baixa do
registrador stack pointer, que vimos anteriormente para a manipulação da stack.
Na prática, isso significa que os 8 primeiros bytes do endereço da pilha ficam
no SPL e os oito restantes, caso seja necessário, ficam no SPH. Dessa forma, os
valores dentro desses registradores dizem ao microcontrolador onde retirar ou
armazenar a próxima variável da stack. Conseguiu compreender como o valor de
um registrador altera o funcionamento do microcontrolador?
Outro uso interessante dos registradores de uso geral é o endereçamento

indireto. No Atmega328, o ponteiro que aponta para o endereço de memória é
implementado dentro dos 6 últimos registadores de uso geral, ou seja, de 0x001A
até 0x001F (MICROCHIP, 2020). Em termos práticos, esses registradores podem
armazenar o endereço de uma variável salva na memória. É interessante saber
ainda que o microcontrolador leva dois ciclos para acessar a variável de forma
indireta, isto porque no primeiro ciclo são acessados os registradores do ponteiro,
e calculado o endereço através da ULA e no outro ciclo a variável é obtida no
endereço calculado (GADRE, 2001).
Os demais registradores, como vimos na Figura 16, são registradores

utilizados para fazer a interface com os dispositivos de entrada e saída.
Basicamente, esses registradores controlam e armazenam a informação que será
49
transmitida do microcontrolador para o periférico e vice-versa. Vamos conhecer

alguns desses registradores e ver um exemplo prático para deixar mais clara
essa definição. Para facilitar a explicação os registradores utilizados aqui são
apresentados no Quadro 2 com o respectivo endereço na memória SRAM e uma
breve descrição.
QUADRO 2 – EXEMPLO DE REGISTRADORES DE E/S DO ATMEGA328
Nome do Endereço
Descrição
Registrador na SRAM
Esse registrador pode ser lido ou escrito, ao
PORTB 0x25
escrever o estado dos pinos é alterado.
Registrador utilizado para dizer se os pinos
associados ao PORTB serão de saída ou entrada.
DDRB 0x24
Escrever “0” define o pino como entrada e “1”
como saída.
Registrador apenas de leitura. Ao ler o registrador
PINB 0x23 PINB são retornados os estados do próprio
registrador PORTB.
Perceba que todos os registradores apresentados na Figura 17 têm

relação com os pinos do microcontrolador, ou seja, com a interface externa do
microcontrolador como outros dispositivos, como sensores, drivers, motores,
LEDs e outros dispositivos. Na prática, o registrado PORTB faz interface com os
pinos 14, 15, 16,17, 18, 19, 9 e 10 do microcontrolador, sendo que o primeiro bit
de PORTB faz referência ao pino 14, chamado de PB0 e o último bit faz referência
ao pino 10, chamado de PB7. Sendo assim, escrever “0” na primeira posição do
registrador PORTB, ou melhor dizendo em PB0, faria com que um nível lógico
alto fosse gerado nesse pino.
NOTA
Em sistemas digitais, e aí os microcontroladores estão incluídos, tudo funciona

a partir de níveis lógicos. O que isso significa? Basicamente que a partir de determinado
nível de tensão o microcontrolador considera um nível lógico alto, e que até um nível
determinado nível de tensão o microcontrolador considera um nível lógico baixo. No caso
do Atmega328, é considerado nível lógico alto tensões a partir de 2,8 V (com limite de 5,5
V para não danificar o microcontrolador), enquanto que, de 0 a 2,3 V é considerado nível
lógico baixo para o microcontrolador, para uma tensão de alimentação de 5,5 V (os níveis
lógicos mudam de acordo com a tensão de alimentação) (MICROCHIP, 2020).
50
Para exemplificar essa interface com o mundo externo, vamos escrever

um código simples em C++, que configuraria todos os pinos de PORTB como
saída e acionaria constantemente um LED conectado ao pino PB0. Esse código é
apresentado na Figura 17.
FIGURA 17 – CÓDIGO PARA ACIONAMENTO DE UM LED NO PINO PB0 DO ATMEGA328
Caso o código da Figura 17 não tenha parecido tão simples para você,
tenha calma! O conceito da programação em C para microcontroladores será visto
mais à frente nesse livro, o que queremos entender aqui é como os registradores
funcionam. Dessa forma, vimos duas operações com registradores nesse código,
vamos analisar cada uma delas. Na primeira o valor 0xFF em hexadecimal foi
atribuído para o registrador DDRB, o que na prática significa que mandamos
o número 11111111 em binário para dentro do registrador, como cada bit do
registrador faz referência a um pino de PORTB, o que fizemos aqui foi configurar
todos os pinos de PORTB, ou seja, de PB0 a PB7 como saída. Na segunda
operação, enviamos o número 00000001 em binário para dentro de PORTB, que
como você já deve imaginar ativa apenas o pino PB0 do microcontrolador. E, caso
você esteja curioso, o operador while (do inglês enquanto) executa um bloco de
código enquanto uma determinada condição (entre parênteses) for verdadeira.
No nosso código exemplo, a condição 1 é sempre satisfeita e o código será sempre
executado de maneira ininterrupta.
O que vimos aqui é uma pequena fração das configurações que podem ser
executadas pelos registradores. Quase tudo dentro de um microcontrolador pode
ser configurado através de um registrador, desde a interface com dispositivos
externos até as interrupções que acontecem durante a operação dele.
51
7 INTERRUPÇÕES
Apesar não de parecer, as interrupções não são um conceito novo neste
livro. Você deve lembrar que no Tópico 2 estudamos o subpasso de interrupção,
em que o microprocessador para sua atividade atual e trata um determinado
evento que está acontecendo. Nos microcontroladores esse recurso é amplamente
utilizado por vários módulos. Vamos nos atentar aqui aos contadores, onde
poderemos ver mais claramente como configurar e tratar uma interrupção.
Contudo, antes de iniciarmos é fundamental que o conceito de contadores

esteja alinhado com você, acadêmico. O contador como o nome sugere é um
módulo presente na grande maioria dos microcontroladores, que realiza a
contagem dos ciclos de máquina, através do clock interno ou de um clock externo
conectado a um dos pinos. Esse módulo é normalmente referido também como
timer justamente por essa possibilidade de gerar atrasos de acordo com uma
determinada quantidade de ciclos de máquina. Além desses recursos, muitos
contadores (como é o caso do presente no Atmega328) possuem o recurso de
gerar ondas PWM, que são ondas quadradas com tempo em baixa e alta definidas
pelo programador, mas que não abordaremos nesse momento.
No modo de operação mais simples o registrador TCNT0 de 8 bits

armazena a contagem binária, sendo incrementado a cada pulso de clock, ou seja,
a cada ciclo de máquina. Quando o TCNT0 atinge o valor máximo (0b11111111),
uma flag chamada Timer/Counter Overflow Flag (TOV0) fica ativa, indicando
que houve um transbordamento do registrador e que a contagem chegou ao
fim. O evento de transbordamento pode produzir uma interrupção, desde
que ela seja configurada no registrador TIFR0 (MICROCHIP, 2020). Quando é
gerada a interrupção o microcontrolador para o que está fazendo e é desviado
para outra rotina. Chamamos essa rotina de tratamento da interrupção pois
nela a programador informa exatamente o que deve ser feito quando aquele
acontecimento ocorrer. Desse modo, poderíamos simplesmente acionar um led
ao estouro do contador, ou qualquer outra atividade que necessitasse de um
atraso para ocorrer.
A maioria das interrupções dentro dos microcontroladores podem ser

ativadas ou desativadas através de registradores específicos, como no caso do
contador, onde temos o registrador TIFR0 como uma espécie de chave liga/desliga
da interrupção. Como já sabemos, vários recursos dentro microcontrolador
utilizam interrupções para tratar algum tipo de ocorrência, mas o que aconteceria
se mais de uma interrupção acontecesse ao mesmo tempo? Bem, nesse caso
a prioridade das interrupções pode ser elencada pelo programador, sendo
informado qual tem preferência em caso de uma ocorrência simultânea.
No caso do Atmega328, para habilitar uma determinada interrupção se

faz necessário primeiramente habilitar as interrupções globalmente através do
registrador de status (SPMCSR). Caso a interrupção seja proveniente de um fator
externo, como a mudança de estado em um pino por exemplo, se faz necessário
habilitar ainda as interrupções externas.
52
DICAS
As interrupções externas são de grande importância em projetos de

microcontroladores. Que tal estudar como configurar as interrupções externas e ainda ver
um exemplo prático nessa área? Confira o artigo em: https://exploreembedded.com/wiki/
AVR_External_Interrupts.
No caso do contador, a interrupção é acionada através de um flag de

interrupção, o TOV0 no caso, havendo a necessidade de “limpar” essa flag, ou
seja, retorná-la para o estado de antes da ocorrência do evento. Contudo não é
sempre que uma flag dispara uma interrupção. Em alguns casos, a interrupção
ocorre simplesmente pela ocorrência da condição.
8 PINAGEM
Obviamente, nem tudo é interno ao microcontrolador. Apesar de toda
a “magia” ocorrer dentro dele, o microcontrolador veio para fazer interface
com o meio externo, seja recebendo dados através de sensores, ou enviando
informações e comandos para motores, LEDs, e outros atuadores. Apesar de
muitos microcontroladores já possuírem tecnologias wireless como WiFi e
Bluetooth integradas, a forma mais utilizada de se comunicar com o meio externo
continua sendo através dos pinos do microcontrolador. Quando falamos da
pinagem nos aproximamos mais do hardware da aplicação, uma vez que teremos
que considerar quais pinos possuem melhor desempenho, adaptabilidade,
ou mesmo os recursos que precisamos para interligar cada hardware externo.
Contudo, temos que levar em consideração também como cada pino impacta
o software ou vice-versa. Quando estamos estudando os registradores, aqui
mesmo nesse tópico, tivemos que entender quais pinos estavam associados ao
registrador PORTB para assim configurá-los, via software, como entrada ou
saída. Devido à importância da pinagem para o desenvolvimento de qualquer
projeto, analisaremos nesse tópico os pinos do microcontrolador Atmega328, de
modo a entender como cada pino funciona e como está interconectado com os
recursos principais do microcontrolador. O mapeamento dos pinos do Atmega328
é apresentado na Figura 18.
53
FIGURA 18 – PINOS DO ATMEGA328 COM RECURSOS ASSOCIADOS POR PINOS.
FONTE: Therib (2015, p. 8343)
Na Figura 18 são apresentados a pinagem do Atmega328, num

encapsulamento chamado no datasheet de 28P3. Esse encapsulamento apesar
de não ser único para o modelo diz respeito a como os chips internos do
microcontrolador foram encapsulados. No 28P3, por exemplo, o microcontrolador
foi encapsulado com 28 pinos, e de uma forma que permite facilmente a conexão
com uma protoboard.
Como pode-se ver também cada pino possui associado módulos do

microcontrolador que estão disponíveis naqueles pinos. Os pinos 7,8, 20 e 22, por
exemplo, são exclusivos para a alimentação do microcontrolador, sendo o quadro
vermelho (VCC) o terminal positivo e o quadro preto (GND) o terminal negativo.
De maneira alguma, esses pinos podem ser invertidos, correndo o risco de perda
do dispositivo caso isso aconteça.
Os pinos associados ao PORTB (PB0 a PB7) possuem a possibilidade de

serem configurados como entrada ou saída, ao passo que todos possuem um
resistor de pull-up interno de modo a evitar ruídos ou estados indeterminados
durante o funcionamento. Dependendo da configuração dos registradores, PB6 e
PB7 podem ainda ser utilizados como entrada para um clock externo, enquanto
PB1 a PB3 podem ser utilizados como saído do sinal PWM ou como saída do
comparador do módulo contador, que estudamos anteriormente.
Podemos destacar ainda o PORTC (PC0 a PC6) que diferente do PORTB

é uma porta de entrada e saída de dados de apenas 7bits. Dentre eles, o PC6
pode ser utilizado ainda como uma entrada de reset para o dispositivo. Os
demais pinos (PC0 a PC5) são associados a conversores analógico-digital, que
podem ser utilizados para a leitura de dados temperatura, tensão e corrente, pelo
microcontrolador.
54
Assim como o PORTB, o PORTD também é uma porta de entrada e saída

de 8bits, mas com algumas diferenças em relação as suas funções secundárias.
Os pinos PD0 e PD1, por exemplo, podem ser utilizados para transmissão serial
de dados com outros dispositivos, enquanto PD2 e PD3 podem ser utilizados
para gerar interrupções externas dentro do Atmega328. Alguns pinos do PORTD
possuem ainda as entradas para um comparador analógico e mais algumas saídas
PWM.
Como vimos, o Atmega328 tem 23 pinos de E/S, mas alguns dependem

da configuração de alguns registradores para trabalhar dessa forma. Assim é
necessário que o projetista considere como os pinos já vem configurados por
padrão e que outros recursos são necessários para o projeto. Por exemplo, não
é sábio utilizar os dois únicos pinos de transmissão serial simplesmente como
entrada e saída de dados, sendo que no futuro esse tipo de comunicação pode ser
necessário e os pinos já serão utilizados. Assim, os recursos de um microcontrolador
devem ser sabiamente utilizados pelo projetista, sempre de forma a otimizar e o
possibilitar um melhor processamento de dados.
55
LEITURA COMPLEMENTAR
EDITORIAL: LINGUAGENS DE PROGRAMAÇÃO PARA SISTEMAS

EMBARCADOS
Equipe Embarcados
Neste artigo pretendemos detalhar as vantagens e desvantagens de cada

uma dessas linguagens de programação, assim como apontar o uso para o qual
elas vêm sendo empregadas no mercado de trabalho.
Introdução
Antes de apontarmos as linguagens para sistemas embarcados, precisamos,
antes, entender o que é um sistema embarcado e a sua diferença para um sistema
desktop.
O quão diferente é programar para sistemas embarcados e desenvolver

aplicativos para ambiente Desktop? No que se refere à linguagem em si, seja ela
qual for, não existe diferença sintática. No entanto, o comportamento e restrições
apresentados nesses ambientes podem ser ligeiramente ou consideravelmente
distintos.
Um sistema embarcado apresenta restrições de hardware, seja de memória

(volátil e não-volátil), seja de processamento, o que faz com que o programador
precise se preocupar com o binário/bytecode gerado, de modo a utilizar o
hardware de forma mais eficiente. Ao passo que num sistema Desktop tem-se a
sensação de que os recursos são “ilimitados”.
Elencamos algumas linguagens que estão sendo empregadas no mercado

de trabalho e têm muita importância e aplicabilidade para a área de sistemas
embarcados. Essa informação é muito importante para quem atua diretamente
na área, principalmente no desenvolvimento de software em projetos. Por isso
que no estudo realizado pelo próprio Embarcados em 2014 foi disponibilizada a
pergunta “Como o projeto embarcado atual é programado?”, a qual foi respondida
por uma amostra de 657 pessoas.
Veja nesse estudo que foi apontado pelo público que a linguagem C é
usada na maioria dos projetos onde atuam, mais de 70%. Não é uma surpresa,
visto as suas características, que serão mostradas logo a seguir. Para efeito de
comparação e conhecimento, confiram também o índice TIOBE, que mede a
popularidade das linguagens de programação pelo mundo uma vez por mês.
Segue uma lista das linguagens que selecionamos.
56
Assembly
Como o contato direto com o hardware é uma característica frequente
encontrada em sistemas embarcados, o contato com a linguagem Assembly torna-
se praticamente inevitável.
Para se desenvolver um firmware, faz-se necessário, de alguma

forma, escrever uma sequência de comandos na memória de programa do
microcontrolador. Esses comandos são códigos de máquina, executados de forma
sequencial. Cada instrução possui um código em hexadecimal e podem aceitar
ou não parâmetros. O fluxo do programa é controlado por instruções de teste e
chamadas de funções.
Ficar escrevendo programa em códigos numéricos é pouco prático, correto?

Para isso foi criada a linguagem Assembly, com a qual são usados mnemônicos,
com uma tradução de um para um com o correspondente código de máquina.
Utilizando uma linguagem de baixo nível como Assembly é preciso

dominar os detalhes da arquitetura interna do núcleo e o mapeamento de memória,
o que é conhecido como Programmers Model. Detalhes como alinhamento de
memória, controle do stack, troca de contexto, etc, entram nessa lista.
Todo compilador de uma linguagem de alto nível, no entanto, gera como

saída o respectivo código em Assembly para verificação do programador.
Atualmente, em projetos profissionais, o uso de Assembly é bastante

restrito, sendo utilizado em código de inicialização dos microcontroladores e em
funções/módulos que precisam oferecer performance alta e conhecida. Também
pode ser empregado em projetos com microcontroladores com baixíssima
quantidade de memória, que apenas realizam um número restrito de operações.
C
A linguagem C foi criada em 1973 por Dennis Ritchie a partir da linguagem
B (criada por Ken Thompson) e BCPL, com a finalidade de evitar futuras reescritas
do sistema operacional UNIX em Assembly quando um novo hardware fosse
criado para ser suportado.
Ela tem sido evoluída, visto que o seu primeiro padrão foi estabelecido
em 1989/1990 pela ANSI e ISO, conhecido como C89 ou C90. O padrão mais atual
é o C11, estabelecido pela ISO em 2011.
É uma linguagem estruturada e de uso geral, mas que tem encontrado no

nicho de sistemas embarcados um grande cliente, com compiladores disponíveis
para os diversos microcontroladores e microprocessadores (RISC e CISC)
existentes no mercado.
57
C é flexível, portável entre arquiteturas computacionais distintas, e

enxuta, possuindo somente 44 keywords. Os compiladores tendem a gerar código
eficiente, visto que a linguagem possui estruturas que são mapeadas diretamente
em instruções de máquina, razão pela qual tem sido utilizada em projetos que
faziam uso da linguagem Assembly.
Mas alguns pontos merecem atenção do programador:
• C oferece uma pobre verificação de run-time;

• O uso de ponteiros pode facilitar o desenvolvimento de uma aplicação,
mas também dificultar (e muito) o seu entendimento. Com eles é possível
acessar posições aleatórias da memória mapeada da arquitetura utilizada,
microcontrolador ou microprocessador. O mal-uso pode ser a corrupção de
dados ou execução opcodes inexistentes, por exemplo;
• O uso da pilha do sistema, pois é uma região de memória não controlada pela
linguagem nem pelo compilador. Por isso que existe técnicas que ajudam a
mensurar o uso dessa região de memória pela aplicação e identificar que o
seu uso excedeu (buffer overflow) os seus limites, o que é chamado de stack
smashing;
• As implementações de alocação dinâmica de memória não são oferecidas pela
linguagem, e sim pelo C runtime do ambiente. Ou seja, o sistema operacional
utilizado ou uma implementação bare-metal deve prover tal estrutura.
C tem sido utilizado largamente no mercado de sistemas embarcados, pois

é o que constatamos, além do estudo realizado pelo Embarcados, em eventos,
conversas com profissionais e divulgação de oportunidades de emprego. Visto
seu vasto uso e enormes vantagens, deve perdurar por muito tempo no mercado.
Em vista disso ele tem sido, inclusive, sendo usada para criar novas linguagens,
tal como Lua e B#.
C#
A linguagem de programação C# foi desenvolvida com o propósito de
ser simples, moderna, de propósito-geral e orientada a objetos, com capacidades
tais como tratamento de exceções, coleta de lixo de memória (garbage collection),
e foi projetada tendo em vista a capacidade de ser adequada para a escrita de
aplicações nativas e embarcadas.
Tanto é que tão logo quanto saiu, já era então possível escrever aplicações
em C# para dispositivos com WindowsCE, e anos depois para os famosos
PocketPCs, chegando ao ponto em que estamos com sistemas Windows Embedded,
Windows Phone e Windows RT, todos eles compatíveis com a plataforma .Net, e,
consequentemente, compatíveis com programas escritos em C#.
A linguagem é tida como muito similar à Java, de modo que muitos

programadores relatam a rápida curva de aprendizado entre ambas as linguagens.
58
Java
Desenvolvida por James Gosling na Sun Microsystems, em 1995, Java
nasceu com o objetivo de ser uma linguagem simples, robusta, orientada a objetos,
independente de arquitetura, interpretada e dinâmica. Um programa compilado
deve ser executado em qualquer arquitetura, sem necessidade de recompilação
(“write once, run anywhere” – WORA).
Em sistemas embarcados Java é encontrada largamente em Smart Cards

(tecnologia Java Card) e em dispositivos móveis, principalmente após o advento
do sistema operacional Android. Com a onda de IoT (Internet das Coisas) e com o
ganho de performance da máquina virtual JavaVM, ela tem sido adotada também
em dispositivos de automação residencial e wearables.
Java não traz consigo o conceito de ponteiros, talvez aí uma das

dificuldades encontradas por programadores C que já estão acostumados com
essa implementação. No entanto, é uma linguagem puramente orientada a objetos.
A alocação de memória é tratada por um Garbage Colector especificado pela
linguagem. O código Java compilado torna-se um bytecode que é interpretado
por uma máquina virtual. Por este motivo, perde-se em performance quando
comparado binários executáveis nativos. A fim de mitigar esse problema, Java
usa o conceito de compilação JIT (Just-In-Time), onde a VM gera um código de
máquina sob demanda durante a execução do bytecode.
Python
É uma linguagem moderna, interpretada, funcional, orientada a objetos,
com tipagem dinâmica e forte, criada por Guido van Rossum em 1991. O que
ouvimos com frequência quando se comenta de Python, principalmente no
mundo dos embarcados, é: “Mas Python é lento, C é mais rápido!”.
Nem sempre “velocidade” é o ponto crítico da solução. Se o sinal que

sai pelo GPIO tem que ter uma frequência alta, então usa um microcontrolador
dedicado e escreva um firmware em C/Assembly e o middleware da solução em
Python, sendo a interface entre a comunicação do GPIO e a conexão com um
banco de dados, criando sockets UDP, TCP, SNMP (pysnmp), AMQP (amqp),
MQTT (mosquitto), criando pacotes e, em seguida, criptografando e enviando
para um servidor N.
Mas Python pode chegar lá embaixo também, com, por exemplo, pyserial
para comunicação serial e pymodbus para comunicação Modbus (que por sinal
utiliza pyserial). Facilmente você pode interagir com o GPIO da sua Raspberry
Pi, Beaglebone Black, Intel Galileo, usando módulos prontos como rpi.GPIO,
Adafruit_BBIO, PinGO (esta suporta todas as demais), além de módulos para I2C
(SMBus), SPI (spidev), CAN (python-can), entre outros.
Pode-se ir mais além e com poucas linhas configurar, abrir, escrever ou

ler, e fechar um arquivo do SysFS referente a um pino do GPIO. Ou ainda pode-se
utilizar MMAP (Memory Mapped Files), usando o endereço de um pino do GPIO
aplicando as mesmas operações do mmap() do C em Python.
59
Como já apontamos, nem sempre a velocidade é o ponto forte da aplicação,

ainda mais nessa era da IoT (Internet das Coisas). A menos que a fração de tempo
seja muito restritiva para interagir com o hardware, usando Python, com módulos
e algumas linhas, é possível ter todo o ecossistema de uma solução que interage
com o hardware, gera dados para web, realiza CRUD em um banco de dados,
e, ao mesmo tempo, envia mensagens a um broker e renderiza numa tela com
PyGTK, PySide, wxPython ou PyQt. Isso tudo numa placa com Linux Embarcado,
e, é claro, atentando-se aos recursos disponíveis. É interessante agora pensar no
tempo que seria necessário para escrever em C o que foi citado anteriormente.
Conclusões
É incontestável que o uso de C dentre as linguagens para sistemas
embarcados é predominante e que tem seu espaço garantido por muito tempo,
dadas as características e requisitos exigidos pela maioria dos projetos eletrônicos
atuais. Além disso, tem sido utilizada para se criar novas linguagens.
No entanto, prezado acadêmico, apesar da multiplicidade de linguagens

para sistemas embarcados, devemos sempre considerar a aplicação fim, não
esquecendo dos seus trade-offs, como tempo de engenharia e o tempo de entrada
do produto no mercado. Nesse sentido, na grande maioria das vezes, a melhor
linguagem é aquela com a qual o desenvolvedor está mais familiarizado e a que
melhor atende os requisitos solicitados para o sistema a se desenvolver.
FONTE: Adaptado de <https://www.embarcados.com.br/editorial-linguagens-para-sistemas-em-

barcados/>. Acesso em: 22 abr. 2021.
60
RESUMO DO TÓPICO 3
• Microcontroladores de uma mesma família possuem aproximadamente

as mesmas características construtivas, diferindo apenas em termos da
disponibilidade de recursos como memórias ou capacidade de processamento.
• O Atmega328 é um microcontrolador de 8 bits com arquitetura Harvard e um

conjunto reduzido de instruções. A maioria delas é executada em apenas um
ciclo de máquina, garantindo uma boa velocidade de processamento.
• A arquitetura de um microprocessador pode ser dividida em módulos,

estando presentes módulos para processamento de instruções, tratamento de
interrupções, e comunicação com dispositivos externos.
• As memórias podem ser divididas em memórias voláteis, onde os dados

armazenados são perdidos após o desligamento do microcontrolador e não
voláteis, onde o dado salvo permanece indefinidamente, até que seja apagado
eletricamente.
• A memória flash presente no Atmega328 é dividida em uma parte maior onde

as instruções são armazenadas e por uma faixa de memória onde o bootloader
é salvo.
• É na memória SRAM que ficam os registradores, assim como a memória

interna onde a stack é implementada.
• Os registradores possuem variados usos dentro de um microcontrolador,

podendo armazenar dados de acordo com a vontade do programador ou
configurar recursos internos como o sentido da informação nos pinos de
PORTB.
• As interrupções acontecem sempre que um evento pré-configurado ocorre

durante o funcionamento do microcontrolador, podendo estas serem
precedidas ou não por uma flag. O programador pode escolher a prioridade
e o tratamento cada interrupção.
61
• Associados aos pinos estão muitos dos recursos internos do microcontrolador,
cabendo ao programador ajustar através do registrador específico como cada
pino será utilizado.
CHAMADA
Ficou alguma dúvida? Construímos uma trilha de aprendizagem

pensando em facilitar sua compreensão. Acesse o QR Code, que levará ao
AVA, e veja as novidades que preparamos para seu estudo.
62
AUTOATIVIDADE
1 O Atmega328, assim como a maioria dos microcontroladores modernos,

possui três tipos de memórias: a EEPROM, a memória flash e a memória
SRAM, de modo que cada uma possui uma aplicação específica no
dispositivo. Acerca da utilização das memórias no Atmega328, classifique
V para as sentenças verdadeiras e F para as falsas:
( ) A EEPROM é uma memória estática com grande capacidade de

reprogramação sendo utilizada para o armazenamento das instruções de
programa.
( ) É na memória SRAM que os registradores estão localizados, sendo esta
uma memória volátil, o que significa que os dados armazenados são
perdidos ao desligar o dispositivo.
( ) A memória flash é dividida em duas seções onde em uma delas está
localizado o bootloader, código responsável por preparar o hardware
para o recebimento de uma nova programação.
( ) É dentro da memória de programa que fica localizada a stack de um
microcontrolador.

a) ( ) V – V – F – F.
b) ( ) F – V – V – F.
c) ( ) F – F – V – F.
d) ( ) F – V – F – F.
2 Para melhor visualização e entendimento, a arquitetura de um

microcontrolador é comumente dividida em blocos, onde é apresentado
como cada módulo se comunica com o todo. A respeito dos blocos que
compõem a arquitetura do Atmega328 e a sua função, associe os itens,
I- Program Counter
II- Watchdog timer
III- I/O Lines
IV- SPI Unit
V- Analog Comparator
( ) Se conectam aos pinos do microcontrolador podendo enviar ou receber

dados de dispositivos externos.
( ) Realiza a comparação entre dois sinais analógicos.
( ) Módulo de transferência serial síncrona, permite ao Atmega328 se
comunicar com outros dispositivos via comunicação serial
( ) contador adicional responsável por evitar que uma operação exceda o
tempo de execução e por retornar o dispositivo do modo de baixa energia.
63
( ) registrador responsável por armazenar o endereço da próxima instrução
a ser executada pelo microcontrolador.

a) ( ) I – IV – II – IV – III.
b) ( ) III – V – II – I – IV.
c) ( ) V – I – II – III – IV.
d) ( ) III – V – IV – II – I.
3 Os registradores, além de outras funções, têm a capacidade realizar a

configuração dos módulos presentes no microcontrolador através da
mudança de bits. Um exemplo bem simples disso são as configurações
das portas de entrada e saída de dados em que um “0” no bit específico
do registrador DDRB faria com que o pino correspondente de PORTB
funcionasse como entrada de dados. Sabendo disso, escreva um código
simples em linguagem C que configure o pino PB3 como entrada, PB5 como
saída e que envie nível lógico alto em PB5 de maneira continua. Use como
base o código na Figura 18.
4 As interrupções executam um papel primordial no tratamento de eventos

dentro de um microcontrolador. Sabendo disso, explique o que é uma
interrupção e forneça um exemplo prático de como um programador pode
utilizá-la a seu favor.
5 Os pinos de um microcontrolador são a forma mais utilizada de se

comunicar com o mundo externo, seja recebendo dados de sensores e
outros dispositivos ou controlando motores, LEDs, displays, entre outros.
Devido à quantidade de módulos, a maioria dos pinos do Atmega328 possui
mais de um recurso atrelado a ele, por exemplo, o pino 1 está associado ao
PORTC e ao RESET. Explique como os pinos devem ser configurados pelo
programador de forma a utilizar um recurso específico.
6 De modo a conectar os recursos internos do microcontrolador ao mundo

externo, cada pino é normalmente associado com mais de um módulo
específico, fazendo com que seja necessária a configuração para o uso de
um outro módulo em um determinado pino. A respeito da pinagem do
Atmega328 e seus diferentes usos, assinale a alternativa CORRETA:
a) ( ) O Atmega328 possui quatro portas de entrada e saída de dados,

nomeados de PORTB a PORTD, sendo todos com 8 bits.
b) ( ) Apesar do Atmega328 possuir apenas um módulo de comunicação
serial, é possível mudar os pinos que estão associados a ele.
c) ( ) Associado ao pino PC6 do Atmega328 está o reset do dispositivo,
sendo necessário desabilitar essa função para utiliza-lo como um pino de
entrada e saída de dados.
64
d) ( ) As marcações VCC e GND indicam como o microcontrolador deve ser
conectado com a fonte de alimentação, sendo necessário atenção apenas
com relação à tensão máxima de alimentação.
65
REFERÊNCIAS
ALECRIM, E. Memórias RAM e ROM. 2011. Disponível em: https://www.
infowester.com/memoria.php. Acesso em: 21 abr. 2021.
AUGARTEN, S. The Most Widely Used Computer on a Chip. [s.d.]. Disponível

em: http://smithsonianchips.si.edu/augarten/p38.htm. Acesso em: 24 mar. 2021.
AYCOCK, S. A história dos microcontroladores. 2017. Disponível em: https://

bit.ly/2WvqccS. Acesso em: 23 mar. 2021.
ELPROCUS. Register Banks and Stack Memory Allocation in 8051 Microcon-

troller. [s.d.]. Disponível em: https://www.elprocus.com/stack-memory-alloca-
tion-and-register-set-in-8051-microcontroller/. Acesso em: 15 abr. 2021.
FERRARI, R. EA075 – Memória. [s. d.]. Disponível em: https://bit.ly/3j1vdkK.

Acesso em: 8 abr. 2021.
GADRE, D. V. Programming and customizing the AVR microcontroller. New

York: McGraw-Hill, 2001.
HENRIQUE, C. INTERRUPÇÕES I. 2016. Disponível em: https://bit.ly/3xbMu-

Na. Acesso em: 4 abr. 2021.
KHILLAR, S. Difference between Von Neumann and Harvard Architecture.

2018. Disponível em: http://www.differencebetween.net/technology/difference-
-between-von-neumann-and-harvard-architecture. Acesso em: 26 mar. 2021.
LIMA, C. B. de; VILLAÇA, M. V. M AVR e Arduino Técnicas de Projeto. Floria-

nópolis: Instituto Federal de Santa Catarina, 2012.
MACÊDO, D. Fundamentos de arquitetura e organização de computadores.

2012. Disponível em: https://www.diegomacedo.com.br/fundamentos-de-arqui-
tetura-e-organizacao-de-computadores/. Acesso em: 2 abr. 2021.
MELNYK, P.; DJAHEL, S.; NAIT-ABDESSELAM, F. Towards a Smart Parking

Management System for Smart Cities. 2019 Ieee International Smart Cities
Conference (Isc2), Casablanca, v. 1, n. 1, p. 542-546, abr. 2020.
MICROCHIP. ATmega48A/PA/88A/PA/168A/PA/328/P: megaavr data sheet.

2020. Disponível em: https://bit.ly/3BT8kss. Acesso em: 7 abr. 2021.
MICROCHIP. ATtiny1617 Product Family. 2017. Disponível em: https://www.

microchip.com/promo/tiny1617-mcu-family. Acesso em: 6 abr. 2021.
66
MONTEIRO, M. A. Introdução à organização de computadores. 5. ed. Rio de
Janeiro: Livros Técnicos e Científicos, 2007.
MTSHALI, P.; KHUBISA, F. A Smart Home Appliance Control System for

Physically Disabled People. 2019 Conference on Information Communications
Technology and Society (Ictas), Durban, v. 1, n. 1, p. 1-5, mar. 2019.
PATTERSON, D. A.; DITZEL, D. R. The case for the reduced instruction set
computer – computer architecture news. Vol. 8, n. 6 ,1980. Disponível em:
https://dl.acm.org/doi/10.1145/641914.641917. Acesso em: 15 jul. 2021.
PEREIRA, F. Microcontroladores PIC: programação em C. São Paulo: Érica,

2009.
PEREIRA, L. S. Dopagem eletrônica. 2010. Disponível em: https://www.infoes-

cola.com/quimica/dopagem-eletronica/. Acesso em: 27 abr. 2021.
RASPBERRY. Raspberry Pi Pico. [s. d.]. Disponível em: https://www.raspber-

rypi.org/products/raspberry-pi-pico/. Acesso em: 23 mar. 2021.
SEMICONDUCTORS, St. STM32G0 Series. [s.d.]. Disponível em: https://www.

st.com/en/microcontrollers-microprocessors/stm32g0-series.html. Acesso em: 24
mar. 2021.
SINGH, K. et al. Designing an Efficient Framework for Violence Detection in

Sensitive Areas using Computer Vision and Machine Learning Techniques. 2018
Tenth International Conference On Advanced Computing (Icoac), Chennai, v.
1, n. 1, p. 74-79, dez. 2018.
STALLINGS, W. Arquitetura e organização de computadores. 8. ed. São Paulo:

Pearson, 2010. 640 p.
TECHTUDO. Computadores a válvulas. 2012. Disponível em: https://glo.bo/3z-

JstPU. Acesso em: 23 mar. 2021.
TECMUNDO. A história dos processadores. 2011. Disponível em: https://www.

tecmundo.com.br/historia/2157-a-historia-dos-processadores.htm. Acesso em: 24
mar. 2021.
THERIB, M. A. Double Gate Security System Based on RFID Technology. Euro-

pean Academic Research, Babylon, v. 3, n. 1, p. 8327-8346, out. 2015.
WAZLAWICK, R. S. História da computação. Florianópolis: Gen Ltc, 2017.
ZHU, Y.; XIE, L.; YUAN, T. Monitoring system for forest fire based on wireless
sensor network. Proceedings of the 10th World Congress on Intelligent Con-
trol and Automation, Beijing, v. 1, n. 1, p. 4245-4248, jul. 2012.
67
68
UNIDADE 2 —
PRIMEIROS PASSOS NA PROGRAMAÇÃO

DE DISPOSITIVOS MICROCONTROLADOS
• entender as principais estruturas da linguagem C++, assim como desen-

volver os primeiros códigos utilizando essa linguagem;
• saber a definição e como funcionam os projetos de hardware e software
livre, além de entender as principais vantagens desse tipo de desenvol-
vimento;
• compreender os detalhes construtivos do Arduino Uno, explorando os
limites elétricos da placa e ferramentas úteis para desenvolvimento;
• entender e utilizar a IDE do Arduino para envio do seu primeiro sketch.
PLANO DE ESTUDOS
apresentado.
TÓPICO 1 – INTRODUÇÃO À LINGUAGEM DE PROGRAMAÇÃO C++

TÓPICO 2 – APRESENTAÇÃO DA PLACA DE DESENVOLVIMENTO
ARDUINO
TÓPICO 3 – CONFIGURANDO E CONHECENDO A IDE DO ARDUINO
CHAMADA

69
70
UNIDADE 2
TÓPICO 1 —
INTRODUÇÃO À LINGUAGEM DE PROGRAMAÇÃO C++
1 INTRODUÇÃO
Pode não parecer, mas a programação se baseia em uma lógica bem
próxima com a que pensamos e tomamos decisões. Você, provavelmente, já
pensou coisas do tipo: “Se estiver chovendo amanhã eu levo um guarda-chuva”.
Esse tipo de estrutura condicional, “se isso acontecer, faça aquilo”, é uma das que
ocorrem com bastante frequência na programação e uma das que vamos estudar
durante o tópico. Apesar de a lógica ser a mesma para qualquer linguagem de
programação, algumas são mais adequadas para determinados propósitos
que outras. O desenvolvimento web, por exemplo, utiliza linguagens como
Javascript e PHP, que já não são vistas tão facilmente para a programação de
microcontroladores.
Apesar de ainda ser requerida em algumas áreas específicas, e ser

especialmente útil para aprender a arquitetura de processadores, a linguagem
Assembly não é mais tão utilizada assim na programação de microcontroladores.
No lugar dela, a linguagem C++ está entre as mais utilizadas para a programação
de microcontroladores. Além de ser uma linguagem de alto nível, a linguagem
C++ possui a vantagem de possuir códigos simples e eficientes, além de possuir
recursos como orientação a objetos, tratamento de exceções e coleta de lixo de
memória (EMBARCADOS, 2015).
Outra linguagem que vem crescendo bastante em diversas áreas

é a linguagem Python, ultrapassando inclusive a linguagem C++ no rank
das linguagens mais utilizadas em 2020 para programação de embarcados
(SPECTRUM, 2020). Apesar do crescimento da linguagem Python, ainda é
natural começar o aprendizado com a linguagem C++, principalmente por ser
a linguagem mais próxima da utilizada para programação do Arduino. Não se
preocupe, a partir dos conhecimentos aqui adquiridos vai ser muito mais natural
para você aprender outras linguagens.
Neste tópico, nós estudaremos a linguagem de programação C++, iniciando

a partir da lógica de programação e indo até o estudo das funções em C++. O
intuito é entregar a você, acadêmico, o necessário para iniciar a programação de
dispositivos microcontrolados.
71
UNIDADE 2 — PRIMEIROS PASSOS NA PROGRAMAÇÃO DE DISPOSITIVOS MICROCONTROLADOS
2 LÓGICA DE PROGRAMAÇÃO
Antes de conhecermos em detalhes a linguagem C++, vamos nos ater ao
que seria o ponto em comum de todas as linguagens: a lógica de programação. A
lógica por si só é um termo interessante de ser visto. Segundo o dicionário, pode-
se definir lógica como “Modo de raciocinar coerente que expressa uma relação de
causa e consequência; raciocínio, método [...]” (DICIO, 2021, s.p.).
Dessa forma, a lógica trata justamente da relação de causa e consequência

que vemos no dia a dia, mas não percebemos. Ao fazer um bolo, por exemplo,
seguimos uma sequência lógica de instruções, onde uma instrução depende
da outra para ser realizada. Podemos dizer assim, que muito do que fazemos
é executado de maneira lógica, seguindo uma sequência de instruções. Na
programação, essa maneira lógica de pensar, a fim de gerar uma sequência
de instruções, a serem lidas pelo computador é conhecido como lógica de
programação. É essencial vermos que, a lógica de programação não depende da
linguagem escolhida. Na verdade, a linguagem é apenas a forma de se comunicar
com o dispositivo.
Dessa forma, é comum que se inicie o processo de desenvolvimento pela

lógica de programação, sendo gerado assim uma sequência de instruções, que
futuramente são implementados em um programa escrito em linguagem x ou
y. A essa sequência de instruções lógicas damos o nome de algoritmo, e é mais
comum vê-los no nosso dia a dia do que você pensa. Um exemplo simples seriam
as receitas, mas podemos citar também os processos industriais, manuais de
instruções e até mesmo as bulas de medicamentos.
Os algoritmos normalmente são representados de três formas diferentes

apresentadas a seguir (VASCONCELLOS; TAMARIZ; BATISTA, 2019). Veremos
para cada forma a representação de um mesmo algoritmo, a fim de deixar o
conceito mais explícito.
2.1 DESCRIÇÃO
Na descrição, o algoritmo é dito diretamente em linguagem escrita. É o
caso das receitas e manuais que descrevemos anteriormente, sendo especialmente
útil para explicar como o algoritmo funciona através de linguagem escrita.
Tomaremos como exemplo o algoritmo para acionamento de um LED. Veremos
no parágrafo a seguir como seria a descrição desse algoritmo.
Verifique se o LED está acesso, caso sim, não faça nada. Enquanto o
LED estiver desligado, verifique se o botão foi pressionado. Quando o botão for
pressionado acione o LED e encerre.
72
TÓPICO 1 — INTRODUÇÃO À LINGUAGEM DE PROGRAMAÇÃO C++
Observe como as condições de causa e consequência se aplicam na

descrição do algoritmo. Caso o LED já esteja acesso (causa), o programa não fará
nada e será encerrado (consequência). Quando o botão for pressionado (causa), o
LED será acesso e o programa encerrado (consequência). Desse modo, fornecemos
uma descrição lógica estruturada a respeito do funcionamento do código. Apesar
da forma de descrição ser talvez a mais distante da estrutura de um código, ela
ainda é uma forma válida para discutir e informar a respeito de um algoritmo.
2.2 FLUXOGRAMA
O fluxograma é a representação gráfica do algoritmo, sendo utilizadas
formas e setas para indicar o sentido de execução das instruções e as decisões
tomadas pelo algoritmo. Vamos representar agora o mesmo algoritmo para
acionamento do LED através de um fluxograma. O fluxograma de acionamento
do LED está representado na Figura 1.
FIGURA 1 – FLUXOGRAMA DE ACIONAMENTO DE UM LED
Observe que foram utilizadas formas diferentes para representar as etapas

do fluxograma. O início e o fim, por exemplo, foram colocados em uma forma
retangular com pontas arredondadas. Isso não foi por acaso. Nos fluxogramas,
cada forma representa um processo específico. O losango é sempre utilizado para
indicar decisões, enquanto o retângulo para indicar a entrada e saída de dados, e
o retângulo com pontas arredondadas para o início e fim do fluxograma.
73
DICAS
As formas apresentadas tendem a ser as mais utilizadas na construção de

fluxogramas, contudo, várias outras estão disponíveis. Dessa forma, recomenda-se a leitura
do artigo disponível em: https://www.venki.com.br/blog/significados-simbolos-fluxograma-
de-processos/, em que é apresentado o significado de mais formas gráficas utilizadas em
fluxogramas.
2.3 PSEUDOCÓDIGO
O pseudocódigo é a forma mais próxima de se representar um algoritmo,
utilizando assim uma linguagem genérica próxima da linguagem escrita, mas
estruturada em formato de código. Veremos, a seguir, como ficaria o algoritmo
de acionamento do LED em um pseudocódigo.
Algoritmo <Acionamento_LED>
Var LED_STATUS
Var BOTÃO_STATUS
Inicio
SE LED_STATUS == 1
FIM
SENÃO
ENQUANTO LED_STATUS != 1
SE BOTÃO_STATUS == 1
ACIONA_LED
FIM SE
FIM ENQUANTO
FIM SE
Fim
Talvez essa tenha sido a forma mais desafiadora de observar o mesmo

algoritmo, mas é também a forma mais próxima do algoritmo expresso em uma
linguagem de programação. Vamos entender parte a parte o que está escrito, a
fim de não restarem dúvidas. A primeira linha do pseudocódigo trata apenas do
nome do algoritmo, enquanto as duas linhas seguintes definem duas variáveis,
que seriam o estado do LED e o estado do botão, são esses valores que serão
testados, como veremos.
A próxima linha estabelece uma condição SE-SENÃO. Se o LED está acesso,

ou seja, caso o valor seja igual a 1, o programa encerra, senão uma outra estrutura
é proposta: o ENQUANTO. Enquanto o LED estiver apagado, o algoritmo segue
verificando se o status do botão é igual a 1, ou seja, vendo se ele foi pressionado.
Quando o botão é pressionado o LED é acesso e o programa encerra.
74
Observe que o código dentro das condições SE-SENÃO e ENQUANTO

foram “afastados” em relação à margem do texto. Essa organização tem na
verdade, o nome de indentação, e é uma forma de visualizarmos melhor a
estrutura do código. Entendendo assim, por exemplo, que a condição de fim
(linha 6), só ocorre caso a condição SE (linha 5) seja verdadeira.
As formas de representação de um algoritmo, que vimos aqui, facilitam

e muito a etapa de planejamento de projetos mais complexos. São também uma
ótima base para a escrita do código em linguagem de programação.
3 A LINGUAGEM C++
Apesar de a lógica de programação ser a base de qualquer código, é
importante que saibamos nos comunicar com o dispositivo que vai executá-lo.
Essa comunicação fica a cargo de uma linguagem de programação, que determina
exatamente como o dispositivo deve se comportar.
Na programação de microcontroladores a linguagem C++ se destaca,

como sendo uma das mais utilizadas atualmente, e com mais projetos escritos. O
estudo dela, neste livro didático, se justifica pela programação do Arduino, que
iremos estudar em detalhes nos próximos tópicos. A forma que vamos programar
o Arduino é extremamente semelhante (não sendo exatamente igual, no entanto)
com a forma de programar em C++. O C++ pode ser utilizado também para a
programação dos mais diferentes dispositivos, como microcontroladores PIC,
Raspberry, ESP32, e até mesmo para programar diretamente os microcontroladores
Atmega, presentes na placa de desenvolvimento Arduino.
É interessante saber que a linguagem C++ não foi construída do zero. Ela
foi desenvolvida a partir da linguagem C, em 1983, no famoso Bell Labs, por
Bjarne Stroustrup. O intuito era desenvolver uma nova linguagem baseado em
C, que fosse tão simples quanto a linguagem original, mas com alguns recursos a
mais (PANOSSO, 2019).
Todo código em linguagem C++ possui uma estrutura padrão onde é

realizada a declaração das instruções e variáveis. Essa estrutura é apresentada na
Figura 2.
75
FIGURA 2 – ESTRUTURA PADRÃO DE UM CÓDIGO ESCRITO EM C++
É dentro da função main que a execução principal do código em C++ está

inserida. Apesar de eventualmente existirem desvios, é nela que são declaradas
as variáveis, estruturas de repetição, operadores lógicos e tudo que precisamos
para desenvolver um algoritmo em C++. Apesar de a Figura 2 trazer uma série de
novos conceitos, precisamos agora nos concentrar apenas na estrutura como ela é.
Durante esse tópico veremos esses conceitos de forma gradual e didática.
4 TIPOS DE DADOS E VARIÁVEIS

Em linguagens de alto nível como o C++, é comum armazenarmos dados
em variáveis, ao invés de registradores, como vimos anteriormente. De forma
simples, uma variável é um endereço de memória utilizado para armazenar
temporariamente um dado. Apesar de ser possível referenciar diretamente o
endereço de memória da variável, é comum deixarmos essa escolha por conta do
compilador.
Neste subtópico, nós estudaremos os tipos de dados e os tipos de variáveis

que podemos utilizar em C++. Veremos que, apesar dos tipos de dados serem
essencialmente iguais aos estudados a nível de máquina, existe uma maneira
diferente de tratá-los utilizando a linguagem C++. Além disso, aprenderemos a
forma certa de declarar e utilizar as variáveis.
4.1 TIPOS DE DADOS

De forma geral a linguagem C++ possui quatro tipos fundamentais de
dados (PANOSSO, 2019), apresentados em detalhes a seguir:
76
• Inteiro (denotado por int): é utilizado para armazenar dados numéricos

positivos e sem casas decimais. As variações do tipo int incluem o short int
que pode ser utilizado para armazenar dados de até 16 bits, o long int que
armazena dados de até 32 bits e por fim o long long int, que armazena dados
de até 64 bits.
• Flutuante (denotado por float): é utilizado para armazenar números inteiros
expressos por vírgula, ou seja, os famosos números decimais. Uma variável
do tipo float utiliza 32 bits de memória. Para definir números inteiros com
maior precisão, podemos utilizar ainda uma variável do tipo double, que tem
precisão de cerca de duas vezes um float, utilizando, para isso, 64 bits de
memória.
• Caractere (denotado por char): ocupa apenas 8 bits e serve para armazenar
até um caractere. O caractere armazenado nesse tipo é convertido em um
valor binário entre 0 e 255, e salvo na memória. É possível definir ainda
um conjunto de caracteres, chamado string. Podemos utilizar strings para
armazenar nomes ou frases, mas sempre dando a devida atenção a utilização
de memória, uma vez que cada caractere ocupa um byte de memória.
• Lógico (denotado por bool): é utilizado para armazenar os dados lógicos true
ou false, sendo utilizado para representar o resultado de operações lógicas.
Sabendo disso, o programador deve ser capaz de predizer o tipo de

resultado que será armazenado em cada variável para denotar também o tipo
certo de dados. Caso um dado maior que o esperado seja armazenado em uma
variável do tipo int, por exemplo, um problema de overflow ocorrerá, gerando um
erro na execução do código.
Cada variável em C++ além de denotar um tipo de dado, possui também

um nome que a identifica dentro do código. Veremos a seguir como declarar
variáveis de forma correta.
4.2 DECLARANDO VARIÁVEIS

As variáveis estão por toda parte dentro de um código em C++, sendo
importante denotar o tipo correto e também um nome adequado para a identificar.
O nome pelo qual referenciamos uma variável é conhecido como identificador.
Para escolher um identificador adequado para uma variável precisamos nos ater
a algumas regras presentes. Primeiro não é possível iniciar o identificador de
uma variável com números. Todo identificador deve iniciar com uma letra ou até
mesmo o underline. Outra regra é que não podemos utilizar caracteres especiais
como $, %, ou & em nenhuma parte do identificador da variável. Por último, a
linguagem C++ tem algumas palavras reservadas que também não podem ser
utilizadas (DELGADO, 2018). A maioria delas está listada na Figura 3.
77
FIGURA 3 – PALAVRAS RESERVADAS DA LINGUAGEM C++
FONTE: <https://bit.ly/2V1cYnJ>. Acesso em: 11 maio 2021.
Como veremos, a maioria dessas palavras são utilizadas dentro da própria

linguagem, sendo intuitivo, depois de algum tempo programando, que elas sejam
evitadas para o uso como identificador de variáveis.
Outro fato que precisamos nos atentar é que a linguagem C++ é o que
chamamos de Case Sensitive. Isso indica que a mudança entre maiúsculas e
minúscula muda totalmente o significado do elemento. Observe, por exemplo, as
duas variáveis a seguir.
bool LEDlamp = true;

bool ledlamp = true;
Na primeira declaração temos uma variável totalmente diferente da

segunda pela mudança na forma como a palavra LED foi escrita. Dessa forma,
é importante prestar atenção nesse detalhe. O exemplo citado mostra também
a forma prática com as variáveis são declaras em C++. Primeiro escrevemos o
tipo da variável, nesse caso temos um tipo booleano, seguido do identificador.
A partir daí temos a opção de atribuir ou não um valor a nossa variável. Caso
escolha atribuir, basta incluir um sinal de igual e o valor. De qualquer forma, é
necessário finalizar com ponto e vírgula, assim como qualquer outra estrutura
em C++.
Por último, é interessante que o identificador das variáveis faça sentido

para o programador. Por isso, escolha identificadores curtos e que identifiquem
rapidamente do que se trata a variável. Lembre-se de que códigos muitas vezes
são lidos por outras pessoas ou são revisitados depois de muito tempo.
78
E
IMPORTANT
Outra forma de deixar o código mais claro e entendível é através dos co-
mentários. Os comentários são textos que o programador pode inserir no código sem
que estes sejam considerados pelo compilador. Em C++, para inserir um comentário em
apenas uma linha, basta incluir no início desta o caractere (//). Para comentários de mais
de uma linha basta incluir antes e depois do trecho de código os caracteres (/*) e (*/).
4.3 CONSTANTES
Enquanto o valor de uma variável pode mudar a qualquer momento
durante a execução de um código, o valor das constantes permanece inalterado do
começo ao fim da execução. Dentro da programação, as constantes são bastante
úteis para armazenar o valor de constantes matemáticas ou físicas, como o valor
de PI, por exemplo, e para armazenar valores que se repetem durante o código.
Suponha que queiramos que um determinado LED seja acesso e apagado duas
vezes em intervalos de um segundo. Poderíamos fazer isso em C++ pelo código
a seguir.
#define TIME 1;
bool ledStatus = false;
int main() {
ledStatus = true;
sleep(TIME);
ledStatus = false;
sleep(TIME);
ledStatus = true;
sleep(TIME);
ledStatus = false;
}
Observe que o tempo que o código deve aguardar para apagar e acender
se repete três vezes dentro do código. Agora imagine que queiramos mudar
esse intervalo de 1 segundo para 3 segundos. Com a constante que definimos
na primeira linha, bastaria que trocássemos o valor após o nome da constante
sem a necessidade de alterar todas as ocorrências do mesmo valor uma a uma no
código. Dessa forma, em códigos maiores o uso de constantes é primordial para
manter a praticidade do código.
É interessante sabermos também que as constantes podem ter diferentes

tipos de dados, não se limitando apenas ao tipo inteiro. E, ao contrário das variáveis,
não precisamos declarar o tipo de uma constante, bastando, como vimos, utilizar
79
a diretiva #define, seguido do nome da constante e do valor. Vale lembrar que o

nome das constantes segue, basicamente, as mesmas regras das variáveis, sendo
que normalmente são utilizadas letras maiúsculas para diferenciá-las.
5 OPERADORES LÓGICOS E RELACIONAIS

Frequentemente buscamos testar uma série de condições durante a
execução de um código. Testes como os apresentados nos argumentos a seguir
são frequentes na programação de microcontrolador.
• O resultado lido pelo sensor foi igual a três?

• A temperatura na sala está menor que 27 ºC?
• O retorno da função foi igual a 1?
• O valor da variável a e da variável b são iguais?
Cada uma dessas validações pode ser realizada com auxílio dos operadores
lógicos e relacionais. Para entender a diferença entre eles basta sabermos que
enquanto operadores relacionais investigam a diferença entre duas expressões,
os operadores lógicos executam funções lógicas dentro de um código.
5.1 OPERADORES RELACIONAIS

Iniciando pelos operadores relacionais, temos basicamente seis tipos deles
na linguagem C++, apresentados no Quadro 1.
QUADRO 1 – OPERADORES RELACIONAIS DA LINGUAGEM C++
Símbolo Descrição
< Menor que
> Maior que
<= Menor ou igual que
>= Maior ou igual que
== Igual a
!= Diferente a
Dessa forma, podemos comparar dois valores. O resultado da operação

será 0, indicando que o resultado é falso, ou 1, indicando que o resultado é
verdadeiro. Esses resultados, como já vimos são valores do tipo bool. Veremos,
a seguir, um código que utiliza os operadores relacionais para indicar se uma
pessoa pode ou não comprar bebidas alcoólicas.
80
int main()
{
int nascimento = 2005;
int ano_atual = 2021;
int idade = ano_atual - nascimento;
printf("Pode comprar? %d\n", idade >= 18);
nascimento = 2001;
idade = ano_atual - nascimento;
printf("Pode comprar? %d", idade >= 18);
}
No código citado são feitas duas tentativas de saber se uma pessoa pode
comprar bebidas alcoólicas, na primeira calculamos a idade de uma pessoa
que nasceu em 2005 e verificamos se ela tem mais de 18 anos. O resultado é
apresentado através da função printf, que imprime na tela o valor que está entre
aspas na função. Perceba, no entanto, que existem dois valores estranhos dentro
das aspas: o %d e o \n. Bem, o %d, imprime naquele local do texto a operação que
está após a vírgula. Isso significa que o resultado da nossa operação (idade >= 18),
vai ser impresso logo ali após a vírgula. O \n, é um caractere especial que pula a
linha de impressão, tendo a mesma função da tecla ENTER nos editores de texto.
Na segunda tentativa verificamos se uma pessoa nascida em 2001 tem

mais de 18 anos. Naturalmente, na primeira tentativa, o resultado deve ser falso,
retornando 0, pois uma pessoa nascida em 2005, tem em 2021 apenas 16 anos e,
portanto, não é maior de idade. Já na segunda, temos uma pessoa nascida em
2001, que tem em 2021 exatamente 20 anos, devendo o resultado do teste ser
verdadeiro, retornando 1.
5.2 OPERADORES LÓGICOS

Os operadores lógicos executam três operações em códigos C++. A
operação E, a operação OU e a operação de negação, NÃO. Cada operador lógico,
com seu respectivo símbolo é apresentado no Quadro 2.
QUADRO 2 – OPERADORES LÓGICOS DA LINGUAGEM C++
Símbolo Descrição
! NÃO (negação)
&& E
|| OU
81
Como você já deve esperar, os operadores lógicos só aceitam valores

booleanos para operação. Dessa forma, podemos estabelecer uma condição como
entrada para cada operador. O operador de negação, por exemplo, tem a lógica
mais simples. Basicamente, o resultado de todo valor booleano que passa por esse
operador tem seu valor invertido, assim 1 se transforma 0, e 0 se transforma em
1. Vejamos o exemplo a seguir.
! (4 == 4) // retorna (0)
A operação retorna zero, pois o resultado dentro dos parêntesis resulta

em um, e esse valor é invertido pelo operador NÃO.
Por outro lado, temos ainda os operadores E e OU, chamados também

de conjunção e disjunção. O operador E resulta em um valor 1 caso os dois
operadores que estiverem sendo testados sejam também 1, de qualquer outra
foram o resultado é 0. Já o operador OU resulta em um valor 1, caso um dos
operadores tenha valor 1, ou se os dois forem 1. Vejamos os exemplos a seguir.
3 > 5 && 4 < 5 // resulta em (0)

7 > 5 && 1 < 8 // resulta em (1)
7 > 5 || 5 < 3 // resulta em (1)
7 < 5 || 5 < 3 // resulta em (0)
Na primeira linha do exemplo temos resultado zero, pois, uma das

afirmações não foram verdadeiras, resultando em zero. Já na segunda linha, a
primeira e a segunda afirmação foram verdadeiras, logo o resultado do operador
lógico será um. Nas duas últimas linhas temos um resultado um, pois uma das
afirmações foi verdadeira, e um resultado zero pois nenhuma das afirmações foi
verdadeira.
Como vimos, os operadores lógicos podem ser usados para conectar

dois operadores relacionais, criando expressões lógicas. Por exemplo, imagine
a situação em que o código devesse acionar um aparelho de ar condicionado
apenas quando a temperatura fosse maior que 30 ºC e tivessem mais de 5 pessoas
na sala. Poderíamos escrever a seguinte expressão para isso.
pessoas > 5 && temperatura > 30
Dessa forma, temos basicamente duas condições sendo testadas, pessoas

> 5 e temperatura > 30, cada uma dessas operações irá gerar um valor booleano,
que será testado pela operação E. Caso ambas sejam verdadeiras, ou seja, caso
existam mais de cinco pessoas na sala e a temperatura seja maior que trinta graus
célsius, o ar condicionado seria ligado. Utilizando operações lógicas podemos
conectar quantas expressões relacionais se queira, criando condições para que o
código tome decisões baseado em mais de uma variável.
82
6 ESTRUTURAS DE SELEÇÃO
Baseado no resultado de operações lógicas e relacionais podemos criar
condições para que um bloco de código seja executado. Mas como poderíamos
fazer isso? Como podemos garantir que o ar condicionado do nosso último
exemplo seja acionado apenas na condição de temperatura e quantidade de pessoas
que queremos? Essa possibilidade pode ser atingida com o uso de estruturas de
seleção. Como o nome nos diz, essas estruturas selecionam os trechos de código
que serão executados ou não, de acordo com as condições impostas. Por essa
característica, podemos dizer também que essas estruturas têm a capacidade de
causar um desvio na execução do código (DELGADO, 2018). Lembra do nosso
exemplo em pseudocódigo? Lá utilizamos uma estrutura chamada SE-SENÃO,
pois bem, essa estrutura de seleção ocorre em C++ também e é chamada de IF-
ELSE. A outra estrutura de seleção se chama SWITCH e veremos também como
ela funciona aqui nesse tópico.
A estrutura IF pode ser utilizada por si só dentro do código, oferecendo

uma opção de desvio, caso a condição dentro dos parênteses seja aceita. Veja a
seguir como realizar a declaração de um IF.
if (condição) {
[bloco de código a ser executado]
}
Observe que código dentro das chaves será executado apenas se a condição
dentro dos parênteses for aceita. Caso a condição não seja verdadeira, o bloco de
código é ignorado e a execução do restante do código continua. E se quiséssemos
incluir uma estrutura que fosse executada apenas quando a condição do IF não
fosse aceita? É aí que entra a estrutura ELSE. Observe a seguir o código anterior
com o ELSE.
if (condição) {
}
else {
[bloco executado caso a condição não seja aceita]
}
Como o código dentro do ELSE só é executado caso a condição do IF não

seja verdadeira não existe a necessidade de parênteses aqui. O ELSE cria uma
outra opção de desvio dentro do código em C++ e é interessante para situações
que que precisamos garantir que todas as condições tenham um bloco de código
a ser executado.
83
NOTA
Com a estrutura IF-ELSE temos agora plenas condições de deixar o nosso

código de acionamento do ar-condicionado funcional. Dessa forma, crie um código
simples que ligue o ar-condicionado caso a quantidade de pessoas seja maior que cinco
e a temperatura na sala seja maior que 30 ºC. Caso essa condição não seja aceita, o
código deve acionar um ventilador. Imprima na tela a frase “ar-condicionado acionado” e
“ventilador acionado” para indicar que o acionamento foi realizado.
Outra estrutura de seleção bastante utilizada é a estrutura SWITCH. Ela é

conhecida por possuir seleção composta, ou seja, com a SWITCH iremos escolher
entre várias opções não somente entre duas opções como no caso IF-ELSE. No
código a seguir vemos a sintaxe da estrutura SWITCH.
switch (variavel) {
case opção1:
[bloco de código 1]
break
case opção2:
break
case opção3:
break
default:
[bloco de código padrão]
break
}
NOTA
Quando nos referimos à sintaxe, estamos nos referindo à forma que a

linguagem exige que uma determinada expressão seja declara. A sintaxe do SWITCH, por
exemplo, prevê uma sequência rígida de termos e símbolos que de outra forma resul-
tariam em erro. Além da sintaxe, temos também a semântica que dá significado a cada
uma das expressões. Para se aprofundar mais nessa temática acesse:
84
Na estrutura SWITCH, a variável entre parênteses é comparada com

cada uma das opções após o CASE. Caso a opção 3, por exemplo, seja igual a
variável entre parênteses, teremos o bloco de código 3 sendo executado. Como
se pode perceber, não é necessário a inclusão desse bloco de código entre chaves.
Contudo, necessitamos incluir ao final de cada bloco a sentença BREAK. O BREAK
realiza o papel de interromper a execução, garantindo que apenas o código da
opção correta seja executado (DELGADO, 2018). Caso nenhuma das opções seja
equivalente à variável entre parênteses, o código em DEFAULT será executado.
Por fim, podemos definir quantos CASE forem necessários, garantindo apenas que
o código não fique longo demais. A fim de elucidar essa estrutura, analisaremos
o código a seguir que identifica qual sinal aritmético foi digitado pelo usuário.
int main() {
char op;
scanf ("%c", &op);
switch (op) {
case '+':
printf ("Selecionado adição");
break;
case '-':
printf ("Selecionado subtração");
break;
case '/':
printf ("Selecionado divisão");
break;
case '*':
printf ("Selecionado multiplicação");
break;
default:
printf ("Nenhuma operação selecionada");
break;
}}
A fim de receber o dado digitado pelo usuário utilizamos a função scanf.

De forma simples, nessa função, definimos entre aspas que apenas entradas do tipo
char (caracteres) seriam aceitas, enquanto após a vírgula indicamos a variável op
para receber esse valor. A partir daí o valor recebido pela variável op foi comparado
em cada um dos CASE, sendo informada a resposta adequada. Caso qualquer outro
caractere seja digitado, o usuário terá a resposta padrão, indicada por DEFAULT.
7 ESTRUTURA DE REPETIÇÃO
Frequentemente existe a necessidade de executarmos uma mesma instrução
várias vezes dentro de uma mesma execução. Digamos que quiséssemos acender
e apagar um LED dez vezes, em intervalos de 3 segundos. Se fossemos escrever as
instruções de acionamento do LED, do intervalo de 3 segundos e de desligamento
85
do LED, todos um abaixo do outro, teríamos quase 40 instruções em nosso código,

para uma atividade simples. Em situações como essa a melhor opção seria o uso
de estruturas de repetição. Basicamente, as estruturas de repetição realizam a
execução de um bloco de código repetidas vezes, enquanto uma determinada
situação é satisfeita.
A primeira estrutura que vamos estudar é o FOR. Utilizamos essa estrutura

sempre que é preciso a repetição do código uma quantidade exata de vezes. Logo
a seguir temos a sintaxe do FOR.
for (inicialização, expressão teste, incremento) {

}
Como se pode observar, o FOR possui necessariamente três elementos: a

inicialização, onde é estabelecido a condição inicial da iteração; a expressão de teste,
que basicamente controla a execução da estrutura, ou seja, enquanto o resultado
da expressão for verdadeiro, o código interno continua sendo executado; e o
incremento que realiza uma alteração na condição inicial a cada iteração. Tomando
como exemplo a condição de acionamento do LED que comentamos no início
dessa seção, podemos utilizar a estrutura FOR para simplificar as coisas, observe!
int LED_status;
int main() {
for (int i = 0; i < 10; i++){
LED_status = 1;
sleep(3);
LED_status = 0;
sleep(3);
}}
Vamos analisar primeiramente a declaração do FOR. Como condição inicial

estabelecemos o inteiro i como sendo igual a zero. Logo em seguida estabelecemos a
condição de que o bloco continue sendo executado enquanto a variável i for menor
que 10, e por fim estabelecemos que a cada iteração o valor de i será incrementado
em um, através do comando de atribuição i++. Dessa forma, o bloco de código
passará a ser executado de forma recorrente, com a variável i sendo incrementada a
cada ciclo. Quando i for igual a 10, a condição estabelecida não será mais atendida
e é interrompida a execução do FOR. Em termos práticos, o LED será acesso e
apagado dez vezes com intervalos de três segundos entre os acionamentos.
86
NOTA
Na programação chamamos de iteração cada repetição de uma sequência de

instruções, após a validação de uma condição. Apesar de se tratar de uma repetição, muitas
vezes temos condições diferentes durante a iteração. No bloco FOR, por exemplo, cada
iteração possui um valor do incremente diferente.
Outra estrutura de repetição que vamos estudar é o WHILE. O WHILE é

normalmente utilizado em situações que estamos aguardando para que algum
evento aconteça, sendo assim é uma condição que não tem uma quantidade fixa
de iterações como o FOR. A sintaxe do WHILE é apresentada a seguir.
while (condição) {
[bloco a ser executado]
}
Como podemos observar, a sintaxe do WHILE é de certo modo mais simples

que a do FOR sendo necessária apenas a declaração da condição entre parênteses.
A cada iteração essa condição é verificada, caso seja verdadeira o bloco é executado
novamente, se não, ocorre o desvio e o código continua sendo executado após o
WHILE. Uma curiosidade é que podemos recriar a mesma funcionalidade do laço
FOR utilizando o WHILE, contudo, a custo de mais linhas de código. Observe a
seguir essa implementação.
int i = 0;
while( i < 10) {
i++;
}
Assim como no FOR, temos uma inicialização de parâmetro (int i = 0),

uma expressão teste (while (i < 10)) e um incremento (i++) a cada iteração. Pode
parecer mais simples ver o bloco FOR dessa forma, por isso o motivo de termos
apresentado ele aqui. Contudo, o ideal é sempre utilizar cada estrutura para seu
propósito específico. Dessa forma, diminuímos a quantidade de linhas de código
e otimizamos o mesmo.
O último laço de repetição que veremos aqui tem um propósito diferente

dos que vimos anteriormente. Tanto o FOR como o WHILE verificam primeiro se a
condição é satisfeita e depois executam o código. No DO-WHILE, que vamos estudar
a seguir, o código é inicialmente executado e depois a condição é verificada. Dessa
forma, o código é executado ao menos uma vez, mesmo que a condição dentro
dos parênteses não seja satisfeita. A sintaxe do DO-WHILE é apresentada a seguir.
87
do {
} while (condição);
Como se pode perceber, a condição vem após a execução do código, o que

garante que este seja executado ao menos uma vez por declaração. Apesar de ser
visto com um pouco menos de frequência que o FOR e o WHILE, o DO-WHILE é
útil em algumas situações específicas.
8 VETORES
Quando falamos em vetores na Unidade 1 nos referimos a um elemento
que referenciava um endereço de memória onde o operador estava. Dessa forma,
através de um vetor, o processador tinha acesso à localização do operador. Na
prática é como se o vetor “apontasse” para onde o operador está. Na linguagem
C++ podemos utilizar também os vetores, mas em um sentido mais amplo. Os
vetores em C++ são utilizados para armazenar uma coleção de elementos de um
mesmo tipo (PANOSSO, 2019). Considere, por exemplo, a idade de três irmãos.
Podemos dizer que o primeiro possui 25 anos, o segundo 31, e o terceiro 19. As
três variáveis aqui são inteiras e, portanto, podemos utilizar um único vetor para
armazená-las. Na prática, ao ser declarado esse vetor, o compilador reservaria três
endereços de memória sequenciais, onde cada endereço receberia um valor. Veja
como seria realizada a declaração do vetor exemplo no trecho de código a seguir.
int idade [3] = {25, 31, 19};
Inicialmente, nós temos a declaração do tipo e o identificador do vetor,

como qualquer outra variável. De fato, todos os elementos dentro do vetor devem
possuir o mesmo tipo, declarado nessa parte. Seguindo, temos o colchete com a
quantidade de elementos do vetor e a atribuição, onde definimos os elementos
entre chaves, separados por vírgula. A Figura 4 apresenta como esses valores são
salvos na memória.
FIGURA 4 – VALORES SALVOS NA MEMÓRIA APÓS A DECLARAÇÃO DO VETOR IDADE
88
Após a declaração do vetor podemos acessar cada um dos valores

declarados pelo seu índice. O índice de cada elemento é basicamente a posição
dele no vetor. Contudo, temos que nos atentar que a contagem dos índices do
vetor inicia em zero, e não em um como é tradicional pensarmos. O código a
seguir apresenta a forma geral de acessar um elemento do vetor.
nome [índice];
Vamos tomar como exemplo, o acesso ao segundo elemento do vetor

idade. Para acessá-lo faríamos da seguinte forma.
printf(“%i”, &idade[1]); // imprime na tela o valor 31.
Como a contagem inicia em zero, o índice do segundo elemento seria 1 e

não 2. Podemos ainda atribuir um novo valor para esse elemento ou até mesmo
usá-lo em outras operações.
idade[1] = 56;
printf(“%i”, &idade[1]) // imprime na tela o valor 56
int a = idade[1]; // a variável a recebe o valor 56
int b = idade[1]*3; // a variável b recebe o valor 168
A aplicação dos vetores na linguagem C++ é ampla, não se limitando

apenas a armazenar os números inteiros como vimos aqui. Além disso, em uma
abordagem um pouco mais avançada, podemos definir também matrizes, que
são frequentemente utilizadas para representar variáveis multidimensionais.
NOTA
O estudo aprofundado de matrizes em C++ pode ser visto no artigo em:

https://www.inf.pucrs.br/~pinho/LaproI/Vetores/Vetores.htm.
9 STRINGS
Durante o estudo de vetores vimos a possibilidade de armazenar uma
sequência de dados de forma sequencial na memória. Esses dados podem ser dos
mais diversos tipos como inteiros, pontos flutuantes ou até mesmo caracteres.
Dessa maneira, podemos utilizar um vetor para representar uma sequência de
caracteres, ou seja, uma palavra. Esses vetores do tipo char são chamados de
strings na linguagem C++. A seguir é apresentada a forma tradicional como uma
string pode ser declarada, a partir da definição de vetores.
89
char nome[] = {‘P’, ‘e’, ‘d’, ‘r’, ‘o’, ‘\0’};
Observe que não declaramos a quantidade de elementos entre colchetes.

Quando isso acontece, o compilador identifica a quantidade de elementos
atribuídos e determina o tamanho do vetor por si só. Além disso, declaramos ao
final da string o caractere nulo ‘\0’. Basicamente, cada string deve terminar com
esse caractere, a fim de evitar erros.
Declarar uma string dessa forma é muito dispendioso uma vez que temos
que declarar cada caractere individualmente entre aspas simples, e o caractere
nulo ao final. Uma forma mais simples, que existe na linguagem C++ é declarar o
texto completo entre aspas duplas, conforme a declaração a seguir.
char nome[] = “Pedro”;
Observe que nesse caso não tivemos que apresentar o caractere nulo. Nesse
tipo de declaração o compilador acrescenta-o automaticamente ao final. Contudo,
observe que ao definir o tamanho de uma string para receber uma determinada
palavra, temos necessariamente que incluir esse caractere na contagem. Por
exemplo, ao declarar a string nome para receber “João”, teríamos que declarar
uma string de cinco caracteres e não quatro, como esperado.
10 FUNÇÕES
Frequentemente nos deparamos com projetos complexos e que exigem
uma numerosa quantidade de linhas de código para atender todas as suas
funcionalidades. Dentro dessa perspectiva, ao invés de apresentar o código
todo como uma grande sequência, se faz interessante dividi-lo em trechos, que
executam uma função especifica dentro do código. Podemos dizer assim que cada
trecho de código dessa divisão seria uma função. Uma função é, basicamente,
um encapsulamento de código que executa uma determinada ação. A divisão do
código em funções, além de permitir uma melhor visualização do que está escrito,
garante que haja um reaproveitamento do código escrito dentro da função em
vários trechos do programa, sendo em geral uma excelente maneira de reduzir o
volume de linhas.
Uma vez definida uma função podemos simplesmente chamá-la

fornecendo os recursos necessários. Ao ser chamada, uma função executa o seu
código interno e pode ou não fornecer uma resposta ao usuário. Dessa forma, não
existe a necessidade de se preocupar com o que existe dentro da função. Podemos
dizer também que existem funções que possuem entradas e saídas de dados.
Mesmo sem perceber já vimos algumas funções durante o nosso estudo. A

própria main() que temos em todo código C++ é uma função, assim como o printf e
scanf também são exemplos de funções. Em sua forma mais simples a função printf
90
recebe um parâmetro de entrada, que é o texto que queremos imprimir na tela e

como resultado temos o valor impresso no terminal. Nós nunca soubemos como
são compostas essas funções, nós simplesmente a utilizamos. A função printf, scanf
e muitas outras são funções da biblioteca padrão do C++, e podem ser utilizadas
simplesmente chamando as funções e fornecendo os parâmetros necessários.
Apesar da grande quantidade de funções que já existem, necessitamos com muita
frequência de desenvolver nossas próprias funções. A definição de uma função é
apresentada a seguir.
tipo NOME (parâmetros de entrada) {

[comandos da função]
[retorno valor]
}
A definição representa o formato geral para se declarar uma função.

Algumas delas não possuem parâmetros de entrada nem muito menos retornam
um valor. O trecho de código a seguir apresenta o exemplo de uma função do tipo
void, que não possui retorno.
NOTA
Na programação, quando falamos de bibliotecas, estamos nos referindo a

conjuntos de funções agrupados em um mesmo arquivo. No caso da linguagem C++,
os arquivos das bibliotecas têm uma extensão .h, e é uma boa prática declará-las no
início do código utilizando a diretiva #include. As funções printf e scanf citadas estão
dentro da biblioteca padrão stdio.h. Podemos incluir essa biblioteca no código através do
comando: #include <stdio.h>.
void imprime_ola(void) {
printf("Olá ");
printf("me chamo ");
printf("robô");
}
int main() {
printf("Quem é você? ");
imprime_ola();
}
Perceba que declaramos uma função sem retorno e sem parâmetros.

Tudo que a função imprime_ola faz é imprimir na tela o texto apresentado. É
importante notar que essa função foi declarada fora da função main. De fato,
nenhuma função pode ser declarada dentro de outra função, por isso temos que
91
fazer essa declaração fora e antes de dela ser chamada. Como vemos no exemplo,
a função imprime_ola foi chamada dentro da função main apenas pelo seu nome
seguido de parênteses vazios.
Essa seria talvez a forma mais simples de declararmos uma função. Mas
se quiséssemos incluir parâmetros e também receber um retorno de uma função?
Bem, primeiro precisaríamos definir o tipo de retorno da nossa função e logo em
seguida determinar os parâmetros que ela vai receber. Uma forma de vermos isso
em prática é na função a seguir que calcula o quadrado de um número.
int cal_quadrado(int val1){

return val1*val1;
}
int main() {
int numero;
printf("Digite um numero: ");
scanf("%i",&numero);
int quadrado = cal_quadrado(numero);
printf("O resultado é: %i", &quadrado);
}
Inicialmente, a função cal_quadrado foi declarada como possuindo

um retorno do tipo inteiro e possuindo apenas um parâmetro (val1). Devido à
simplicidade da função, não foi preciso declarar nenhuma variável adicional,
incluiu-se apenas o comando return com o resultado da multiplicação do valor
fornecido por ele mesmo. O comando return, de forma geral, retorna o resultado
da função ao ponto onde ela foi chamada. Nesse caso, o valor retornado pela
função cal_quadrado é recebido pela variável quadrado, sendo passado como
parâmetro o valor digitado pelo usuário no teclado.
Como vimos no exemplo anterior, ao chamar uma função com parâmetros

é necessário fornecer os parâmetros necessários para a sua execução, devendo
esse também ser compatível em tipo ao valor esperado. Caso a função possua
retorno é necessário também apresentar uma variável para receber o resultado da
função, também compatível em tipo ao valor retornado.
Além das funções citadas podem existir ainda funções com parâmetros
e sem retorno e, inversamente, sem parâmetros e com retorno. Contudo, essas
funções são apenas variações das já apresentadas, sendo necessárias apenas em
situação bem específicas.
92
NOTA
O conteúdo estudado neste tópico, apesar de ter apresentado uma boa

base em lógica de programação e na própria linguagem C++, está longe de ser um
guia definitivo e completo nessa área. De fato, poderia ser escrito um livro completo e
volumoso apenas com esses dois temas. No fim, o que estudamos aqui será o ideal para
o nosso propósito que é ser capaz de programar um microcontrolador. Para um estudo
mais aprofundado, é recomendada a leitura do livro: C: Como Programar, dos autores
Paul e Harvey Deitel.
93
RESUMO DO TÓPICO 1
• Cada código, independente da linguagem de programação, possui um

algoritmo associado que pode ser visualizado através de uma descrição, ou
de um fluxograma ou de um pseudocódigo.
• A linguagem C++ foi desenvolvida a partir da linguagem C. Cada código

escrito em C++ possui uma estrutura básica composta essencialmente de uma
função principal, chamada main, onde a execução principal acontece.
• Variáveis são declaradas através do tipo de dado que será armazenado e um

identificador, não sendo permitido usar palavras restritas para isso.
• Constantes são declaradas sem a necessidade de informar o tipo de dado.

Contudo, não existe também a possiblidade de alterar o seu valor durante a
execução do código.
• Operadores lógicos e relacionais são utilizados para testar condições durante

a execução do código. Junto às estruturas de seleção é possível ainda desviar
a execução do código de acordo com o resultado desses testes.
• Estruturas de repetição são utilizadas quando um determinado bloco de

código deve ser executado várias vezes, evitando assim que as mesmas
instruções sejam declaradas repetidamente.
• Vetores oferecem a possibilidade de armazenar vários elementos de um

mesmo tipo em uma única variável. Neles, cada elemento é indexado através
de um índice.
• Strings são basicamente vetores de caracteres. Cada string deve terminar

com o caractere nulo, sendo necessário inclui-lo ao contar a quantidade de
elementos da string.
• Funções são trechos de código separados intencionalmente, de modo a serem

reaproveitados em vários pontos do código.
• Cada função tem a capacidade de receber parâmetros e devolver um retorno

ao ponto onde foi chamada. Os parâmetros a serem fornecidos e o retorno da
função estão de acordo com o que foi declarado na própria.
94
AUTOATIVIDADE
1 A lógica de programação é o que há de comum em todo código, independente

da linguagem de programação que este tenha sido escrito. Dessa forma, é
comum se utilizar das representações como a Descrição, o Fluxograma e o
Pseudocódigo para representar a lógica do processo antes de implementá-
lo na linguagem alvo. De acordo com o que se entende por cada uma dessas
representações, classifique V para as sentenças verdadeiras e F para as
falsas:
( ) Na descrição, o algoritmo é representado através da linguagem escrita

estruturada em formato de código.
( ) O fluxograma apresenta de forma gráfica o algoritmo, utilizando-se
de formas e setas para indicar o sentido e os processos que ocorrem na
execução do algoritmo.
( ) O pseudocódigo seria a melhor forma de descrever um algoritmo,
podendo utilizá-lo inclusive para explicar a outra pessoa como o algoritmo
funciona.

a) ( ) V – F – F.
b) ( ) V – F – V.
c) ( ) F – V – F.
d) ( ) F – F – V.
2 Cada variável na linguagem C++ é declarada como possuindo um

identificador e um tipo. Esse último deve concordar com o tipo de dado que
está sendo armazenado pela variável. Sobre os tipos de dados presentes na
linguagem C++, associe os itens, utilizando o código a seguir:
I- int
II- float
III- char
IV- bool
V- String
( ) Ocupa normalmente 8 bits, sendo convertido entre um valor de 0 a 255 e

salvo na memória.
( ) Representam os números positivos e sem casas decimais.
( ) Utilizado para representar o resultado de operações lógicas.
( ) Formando por um conjunto de caracteres, utilizados para expressar
palavras e frases.
( ) Representam os números inteiros expressos por virgula.
95
a) ( ) V – III – I – II – IV.
b) ( ) III – I – IV – V – II.
c) ( ) II – I – IV – V – III.
d) ( ) V – I – IV – III – II.
3 Os operadores lógicos e relacionais são a melhor forma de verificar se

determinadas condições são satisfeitas em C++. Com base na funcionalidade
de cada um desses operadores, analise as sentenças a seguir:
I- Os operadores lógicos podem ser utilizados para conectar expressões

relacionais, criando assim a possibilidade de decisão baseada em mais de
uma variável.
II- Ao contrário dos operadores lógicos, que operam utilizando valores
booleanos, os operadores relacionais realizam a comparação entre valores
numéricos.
III- Os operadores lógicos, diferindo dos operadores relacionais, produzem
como resultado valores booleanos, denotados por true e false.
Assinale a alternativa CORRETA:

a) ( ) As sentenças I e II estão corretas.
b) ( ) Somente a sentença II está correta.
c) ( ) As sentenças I e III estão corretas.
d) ( ) Somente a sentença III está correta.
4 As estruturas de seleção, junto aos operadores lógicos e relacionais,

produzem condições para que desvios sejam realizados dentre um código,
isso significa que dependendo do resultado desses operadores, um
determinado bloco de código pode ser executado ou não. Sabendo disso,
crie um código simples que peça ao usuário para inserir dois números. Caso
os dois números sejam iguais, o código deve imprimir na tela o “IGUAL”,
caso sejam diferentes o código deve imprimir “DIFERENTES”.
DICA: Utilize o compilador on-line de C++ em: https://www.onlinegdb.com/

online_c_compiler.
5 As funções em C++ permitem uma modularização do código, separando

trechos de código que podem vir a ser utilizados em vários pontos de
código. Neste contexto, desenvolva uma função que calcule a média de dois
valores inteiros. Use essa função para calcular a média entre dois valores
inseridos pelo usuário.
96
UNIDADE 2
TÓPICO 2 —
APRESENTAÇÃO DA PLACA DE
DESENVOLVIMENTO ARDUINO
1 INTRODUÇÃO
Como estudamos até aqui, os microcontroladores desempenham papel
fundamental no desenvolvimento de novas tecnologias, sendo vistos nos
mais diversos contextos e aplicações. Contudo, programar diretamente um
microcontrolador é, muitas vezes, uma tarefa desafiadora, principalmente para
quem está iniciando nessa área. Além da necessidade de se programar diretamente
em relação ao hardware desses dispositivos, são necessários componentes a mais
como reguladores de tensão, adaptadores USB-Serial, osciladores, entre outros.
Foi pensando nessa necessidade que surgiram as placas de desenvolvimento. Elas
propiciam, principalmente para quem está iniciando, todo o hardware necessário
para o desenvolvimento, além de oferecer uma forma mais fácil de programar e
enviar os códigos a placa. Por conta de ser uma solução geral, muitas vezes, as
placas de desenvolvimento não são indicadas para a produção de projetos em
grande escala. Contudo, elas proporcionam uma forma mais simples de aprender
e desenvolver os primeiros projetos.
A partir dessa necessidade, vários fabricantes colocaram no mercado

placas de desenvolvimento próprio, sendo a Arduino a que mais tem ganhado
visibilidade. As placas de desenvolvimento Arduino tem ganhado destaque
principalmente por possuírem software e hardware livre, o que significa
que qualquer um pode ter acesso aos arquivos de desenvolvimento e adaptá-
los de acordo com suas necessidades (podendo até mesmo desenvolver sua
própria placa). Além de tudo, o Arduino foi desenvolvido para ser simples,
proporcionando a estudantes e entusiastas um bom ponto de partida na área.
Para iniciar o desenvolvimento, na maioria dos casos, além da própria placa,
basta um cabo USB e um computador ou notebook.
Neste tópico, nós faremos um primeiro contato com as placas de

desenvolvimento Arduino. Será apresentado o conceito de hardware e software
livre e o motivo desse movimento vir ganhando força nos últimos anos. Veremos
os diversos dispositivos produzidos hoje pela Arduino e a forma de integrá-los as
mais diversas aplicações. Por fim, estudaremos a arquitetura do Arduino Uno. O
foco nesse ponto é descobrir todos os recursos que a placa possui para utilizá-los
no desenvolvimento dos mais diversos projetos.
97
2 HARDWARE E SOFTWARE LIVRE

A chamada propriedade intelectual garante ao inventor a exclusividade de
uso e comercialização da sua ideia, sendo qualquer tipo de arquivos relacionado
de uso confidencial. Além de tudo, a propriedade intelectual garante ao inventor
o direito de usufruir dos benefícios da sua invenção, o que sem dúvida é justo
de várias formas. Contudo, em fevereiro de 1998 um conceito alternativo a esse
surgia (CANALTECH, 2021). O movimento open-source veio com o conceito de
software livre, através do qual o software desenvolvido se torna aberto para a
comunidade, oferecendo aos usuários a opção de estudar, acessar e desenvolver
o código-fonte. Apesar de parecer estranho em um primeiro momento, o
movimento open-source objetiva o desenvolvimento rápido da aplicação de forma
colaborativa, com a revisão da própria comunidade. Para essa última, os projetos
open-source garantem a oportunidade de programadores iniciantes terem acesso
e trabalharem nesses projetos, além de oferecer ferramentas gratuitas para a
comunidade. Softwares conhecidos que são open-source incluem o Mozilla Firefox,
VLC Media Player, Audacity, BitTorrent, entre outros.
NOTA
Apesar de serem termos correlatos, open-source e software livre não signifi-

cam a mesma coisa. Enquanto o termo software livre indica a capacidade de distribuição,
modificação e até mesmo comercialização, o termo open-source afirma apenas que o
código está aberto para a comunidade.
Por estar disponível para a comunidade de desenvolvedores, o software

livre apresenta uma série de benefícios como: custo reduzido de desenvolvimento,
maior confiabilidade, independência de fornecedores e um desenvolvimento
mais rápido. Por outro lado, segundo a Open Source Initiative (OPI), grupo que
deu início ao termo open-source, existem dez pontos importantes para que um
software possa ser considerado livre (DEBIAN, 2004):
1. Redistribuição livre: a licença do software livre não pode restringir qualquer

pessoa, empresa ou instituição de revender ou dar o software agregado a
outros programas.
2. Código FONTE: Deve ser incluído para distribuição o código fonte da
aplicação, assim como, a versão compilada.
3. Trabalhos derivados: Deve ser permitido a distribuição de trabalhos derivados
pela mesma licença do trabalho original.
98
TÓPICO 2 — APRESENTAÇÃO DA PLACA DE DESENVOLVIMENTO ARDUINO
4. Integridade do autor do software: A licença deve permitir a distribuição

do programa modificado, contudo, pode ser requisitado que um nome ou
número de versão diferente seja utilizado, a fim de manter a integridade do
software original.
5. Discriminação contra grupos ou pessoas: A licença não pode fazer distinção
entre grupos e pessoas, devendo ser distribuído igualmente.
6. Discriminação contra áreas de conhecimento: A licença não pode restringir
ninguém de fazer uso do software independente da área de conhecimento.
7. Distribuição da licença: Os diretos associados a um programa devem ser
válidos para todos ao qual o programa é redistribuído, sem a necessidade de
licenças adicionais.
8. Licença não deve ser específica a um produto: os diretos associados a um
programa não dependem do mesmo ser parte de um conjunto de programas.
Em outras palavras, ao ser distribuído individualmente, o programa detém a
mesma licença do conjunto de programas.
9. Licença não pode restringir outros softwares: A licença não pode restringir
outros programas que sejam distribuídos juntos com o programa licenciado.
10. Licença neutra com relação à tecnologia: A licença não pode estabelecer uma
única tecnologia, estilo ou interface para o programa desenvolvido.
Dessa forma, os dez pontos apresentados estabelecem as regras para a

utilização e distribuição de softwares livres. O conhecimento desses pontos é
útil para que todos possam fazer um bom uso desses recursos, de acordo com a
conveniência de cada um.
Da mesma forma que o software livre, mais recentemente, surgiu o conceito

de hardware livre, onde projetos de hardware também são distribuídos de forma
livre a comunidade. Nesses projetos são compartilhados esquemas elétricos, lista
de materiais, PCB, layout das placas e até mesmo o código fonte. A USP, por
exemplo, possui uma plataforma de hardware livre, com vários projetos. Vale a
pena conferir: https://hardwarelivreusp.org/projetos/.
Um exemplo tanto de software como hardware livre, como já sabemos, é

a placa de desenvolvimento Arduino. Nesse projeto, tanto o esquema elétrico da
placa, como o ambiente de desenvolvimento integrado (IDE) estão disponíveis
e podem ser utilizados por terceiros. Dessa forma, poderíamos simplesmente
imprimir o circuito impresso (PCB) da placa e utilizando o conhecimento de
hardware e software disponível, montar nossa própria placa Arduino. No entanto,
apesar do projeto ser livre, a marca Arduino possui direitos autorais, não sendo
possível utilizar exatamente o mesmo nome e a logo da empresa. Contudo, é
completamente possível, sendo bastante visto em ofertas na internet, placas que
utilizam o mesmo projeto com nomes similares.
99
NOTA
Apesar dos direitos reservados à marca Arduino e a possibilidade de criar placas

genéricas, existe ainda muita falsificação. O artigo em: https://blog.arduino.cc/2013/07/10/
send-in-the-clones/ trata de forma mais aprofundada o que caracteriza uma placa oficial
Arduino, uma genérica e uma falsificação.
3 A FAMILIA ARDUINO
Dentro da perspectiva de mercado, a Arduino é hoje uma marca que oferta
ao mercado diversos tipos de placas de desenvolvimento, shields (veremos o que
é isso nessa mesma sessão) e acessórios. Apesar da variedade de dispositivos,
todos possuem hardware aberto, sendo possível acessar o arquivo esquemático
e a PCB diretamente nas especificações técnicas de cada dispositivo, na página:
https://www.arduino.cc/en/Main/Products. Apesar de serem apresentados aqui
os principais modelos da família Arduino é recomendado o acesso diretamente
a página.
Alinhado com as novas tendências, a empresa vem trazendo ao mercado

dispositivos voltados para a aplicação em Internet das Coisas (IoT), sendo assim
providos de conexão WiFi e Bluetooth integradas.
NOTA
Internet das Coisas representa um novo paradigma em que os objetos do dia

a dia passam a estar conectados à Internet, criando assim uma rede de transmitir dados e
controlar esses dispositivos de forma remota.
Buscando também simplificar a integração com diferentes tipos de

hardware estão disponíveis os shields, que são circuitos desenhados para
encaixarem perfeitamente nas placas Arduino, sem a necessidade de jumps, ou
pontos de solda. Um dos shields mais conhecidos é o Arduino Motor Shield que
permite o controle de motores CC e motores de passo através de uma conexão
direta com a placa Arduino Uno. Sem o shield, o circuito de controle do motor
deveria ser soldado em uma placa e conectado ao Arduino através de jumps, o
que certamente seria mais trabalhoso para o desenvolvedor.
100
Dentre as principais placas de desenvolvimento podemos citar o Arduino

Uno, o Arduino Nano, o Arduino Leonardo e o Arduino Mega. Cada placa possui
uma aplicação ideal dependendo do projeto. Assim, vamos analisar a seguir cada
uma delas.
3.1 ARDUINO UNO

O Arduino Uno foi a primeira placa desenvolvida pela Arduino e é
também a mais utilizada em aplicações gerais. Diferente de algumas placas, o
dispositivo pode ser alimentado tanto por um cabo USB, como por uma entrada
de alimentação. O Arduino Uno atende bem as necessidades dos iniciantes na
área, sendo a escolhida para continuar os nossos estudos.
3.2 ARDUINO NANO

O Arduino Nano é a menor placa desenvolvida pela Arduino. Apesar
de possuir recursos similares ao Arduino Uno, o Nano foi desenhado para
aplicações em que o tamanho importa mais que a capacidade de processamento.
Recentemente foram lançadas versões do Arduino Nano, voltados para aplicações
de IoT, que já possuem integrado tecnologia Bluetooth e WiFi, sem a necessidade
de um módulo externo. A Figura 5 apresenta a vista do Arduino Nano.
FIGURA 5 – PLACA ARDUINO NANO CLÁSSICA
FONTE: <https://store.arduino.cc/usa/arduino-nano>. Acesso em: 20 maio 2021.
3.3 ARDUINO LEONARDO

O Arduino Leonardo é bem parecido com a placa de desenvolvimento
Arduino Uno, mas com algumas melhorias. Entre elas podemos citar a maior
disponibilidade de porta de E/S, e o protocolo de comunicação USB integrada
101
ao microcontrolador. Da mesma forma que o Arduino Uno, o Leonardo possui

uma entrada para alimentação por fonte externa. A Figura 6 apresenta a placa de
desenvolvimento Arduino Leonardo.
FIGURA 6 – VISTA SUPERIOR DA PLACA ARDUINO LEONARDO
FONTE: <https://store.arduino.cc/usa/leonardo>. Acesso em: 20 maio 2021.
3.4 ARDUINO MEGA

O Arduino Mega foi pensado para ser uma placa mais robusta em relação
às citadas anteriormente. A primeira diferença está na maior disponibilidade de
portas E/S, entradas analógicas, portas PWM e portas seriais. A placa é recomenda
assim para aplicações maiores com grande número de sensores e dispositivos
conectados.
4 ARQUITETURA
Como vimos na sessão anterior, o Arduino Uno é a placa de
desenvolvimento mais indicada para de fato colocarmos a mão na massa e
começarmos a programar um microcontrolador. Além disso, já conhecemos bem
o microcontrolador presente nessa placa: o Atmega328P, o que sem dúvida irá
facilitar nossos primeiros passos. Neste subtópico veremos a arquitetura que
compõe a placa de desenvolvimento Arduino Uno. O intuito é saber os recursos
que podem ser utilizados durante o desenvolvimento de projetos e os limites
elétricos da placa, de forma a evitar danos permanentes, decorrentes do mal-uso.
Inicialmente, a Figura 7 apresenta a vista superior da placa Arduino

Uno. Podemos observar com certa facilidade o microcontrolador Atmega328P
conectado a placa, assim como um conector jack para conexão com fontes de
alimentação. E quanto as demais partes? Para que servem?
102
FIGURA 7 – VISTA SUPERIOR DO ARDUINO UNO, DESTACADAS AS PRINCIPAIS PARTES DA

PLACA
FONTE: Adaptado de: <https://bit.ly/3l5DhUs>. Acesso em: 20 maio 2021.
Nas duas laterais da placa temos os pinos de conexão. Na parte superior

estão disponíveis 14 pinos digitais de entrada e saída de dados. Os pinos que
contém um til (~) na frente podem ser utilizados também como saída PWM. Já os
pinos 0 e 1 são os responsáveis pela comunicação serial do dispositivo. Enquanto
o dispositivo está ligado a porta USB, estes pinos são utilizados para transmissão
de dados entre o microcontrolador e o computador. O conversor USB-Serial
destacado na Figura 7 é o responsável por essa interface. Os pinos 2 e 3 podem
ser utilizados também para a implementação de interrupções externas. Na parte
inferior estão localizados 6 pinos de entrada e saída analógica, cada uma com
resolução de 10 bits. Mais à esquerda tem-se os pinos de saída de tensão 3,3V,
5,5V e GND. O pino de reset é conectado ao reset do microcontrolador e pode
ser usado para que outros dispositivos reiniciem o dispositivo. Uma outra forma
seria através do botão de reset indicado na parte superior esquerda da Figura 7.
O Arduino Uno, como já sabemos, pode ser alimentado através de uma

porta USB na qual é esperada a tensão padrão de 5V, ou por um conector jack.
Através do conector são permitidas tensões entre 7V a 12V, dessa forma, a tensão
de entrada é reduzida, através do regulador de tensão, também destacado na
Figura 7, para a tensão de 3,3V e 5V, essa última a qual o microcontrolador opera.
Uma outra forma de alimentar o Arduino é através do pino Vin, nessa situação
a tensão também passa pelo regulador de tensão podendo ser utilizado também
tensões entre 7V e 12V.
A fim de proteger a porta USB do computador contracorrente reversa,

é incluso ainda um circuito de proteção composto por um fusível e varistores.
Um pequeno ferrite também é incluído para evitar que ruídos provindos do
computador, pela porta USB, entrem na placa (SOUZA, 2013a).
103
O Arduino Uno possui ainda um pequeno LED, presente na placa,

conectado ao pino 13. Dessa forma, pode-se utilizar esse LED para testar pequenas
lógicas como piscar um LED, ou verificar se alguma condição está ocorrendo.
Fisicamente, deve-se tomar cuidado com os pinos da parte posterior da

placa. Como apresentado na Figura 8 estes ficam expostos havendo o risco de
gerar um curto-circuito ao apoiar a placa em uma superfície metálica.
FIGURA 8 – VISTA SUPERIOR DA PARTE TRASEIRA DA PLACA ARDUINO UNO
FONTE: <https://store.arduino.cc/usa/arduino-uno-rev3>. Acesso em: 20 maio 2021.
Outro detalhe é que não existe um botão para ligar/desligar na placa. O

desligamento do dispositivo acontece simplesmente removendo a alimentação.
Tendo conhecimento do hardware podemos seguir agora o software.

No próximo tópico exploraremos como ocorre a programação do Arduino.
Entenderemos o ambiente de desenvolvimento e deixaremos tudo pronto para
de fato iniciar os primeiros projetos. Animado?
104
RESUMO DO TÓPICO 2
• O movimento software livre consiste na abertura do código fonte para a

comunidade como um todo, permitindo a colaboração e o desenvolvimento.
• O software livre possui uma série de benefícios, como o desenvolvimento

acelerado com custo reduzido da aplicação, além de uma maior confiabilidade
nos resultados obtidos.
• O projeto de software livre deve estar baseado em 10 pontos fundamentais,

que garantem de forma geral a capacidade de redistribuição do código e a não
acepção de pessoas e áreas conhecimento.
• A partir do conceito de software livre surgiu também o hardware livre,

que, pautado nos mesmos princípios, distribui projetos de hardware para o
desenvolvimento da comunidade.
• O Arduino é um projeto de software e hardware livre, sendo possível através

dos arquivos distribuídos montar uma placa genérica para uso próprio ou até
mesmo para venda.
• A Arduino possui uma série de placas de desenvolvimento, sendo cada uma

indicada para um tipo de aplicação diferente.
• Dentre as placas apresentadas, a Arduino Uno é a que possui um melhor

conjunto de ferramentas para iniciantes.
• A placa Arduino Uno possui entradas e saídas analógicas e digitais, que em

alguns casos podem ser utilizados também como saída PWM, comunicação
serial ou entradas de interrupção.
• A tensão ideal para alimentação do Arduino Uno fica entre 7V e 20V, com
exceção da alimentação via USB que é feita diretamente em 5V. A entrada de
tensão é ainda regulada para tensões de 3,3V e 5V.
105
AUTOATIVIDADE
1 Através dos chamados softwares livres é possível que a comunidade

desenvolva e usufrua de várias aplicações. Sobre os softwares livres,
assinale a alternativa INCORRETA:
a) ( ) O desenvolvimento de softwares livres costuma ser mais rápidos e

menos onerosos devido à participação da própria comunidade.
b) ( ) A licença de um software livre poder restringida para uma determinada
área de conhecimento. Essa restrição acontece principalmente para
evitar a venda não autorizada desses softwares.
c) ( ) Softwares livres proporcionam a programadores iniciantes o contato
e até mesmo a oportunidade de contribuir com projetos profissionais,
acelerando o seu desenvolvimento na área.
d) ( ) A licença de um software livre não pode restringir a venda do mesmo
agregado a outros programas.
2 A Arduino disponibiliza hoje ao mercado uma grande variedade de placas

de desenvolvimento, sendo cada uma adequada a um tipo específico de
aplicação. Sobre os recursos presentes nas placas Arduino, associe os itens,
I- Arduino Uno.
II- Arduino Leonardo.
III- Arduino Mega.
IV- Arduino Nano.
( ) Utilizado principalmente em aplicações que o tamanho importa mais que

o processamento e a capacidade de portas de E/S de dados.
( ) Além de poder ser alimentado também através de uma fonte externa,
oferece uma maior quantidade de porta E/S e comunicação USB integrada
ao microcontrolador.
( ) É a placa mais adequada para iniciantes e para propósitos gerais,
possuindo uma boa quantidade de portas de E/S digitais e analógicas.
Além de possibilitar a alimentação da placa de duas formas.
( ) É a placa mais robusta da linha Arduino, oferecendo uma quantidade
maior de portas digitais e analógicas, portas PWM e portas seriais.

a) ( ) IV – I – II – III.
b) ( ) IV – II – I – III.
c) ( ) I – II – III – IV.
d) ( ) II – I – III – IV.
106
3 A placa de desenvolvimento Arduino Uno oferece todo o hardware
necessário para o desenvolvimento de projetos, bastando para projetos
mais simples apenas um cabo USB e um computador para desenvolvimento
do sketch. Com base na estrutura presente no Arduino Uno, analise as
sentenças a seguir:
I- O Arduino Uno possui duas formas de alimentação. A primeira através de

fontes externas, onde são permitidas tensões entre 7V e 20V e a segunda
através do cabo USB onde a placa é alimentada diretamente em 5V.
II- Dentro os pinos disponíveis no Arduino Uno, os que possuem um til (~) na
frente podem ser utilizados para transmissão de dados via comunicação
serial.
III- O conversor USB-Serial presente no Arduino Uno é responsável pela
comunicação entre a placa e computador. Dessa forma, os pinos 0 e 1,
que também possuem comunicação serial, podem ser utilizados de forma
independente.

b) ( ) Somente a sentença I está correta.
c) ( ) As sentenças I e III estão corretas.
4 Algumas aplicações, como o uso de motores elétricos, podem ocasionar

correntes reversas em que, se não fosse o circuito de proteção do Arduino,
danificariam a porta USB do computador. Pesquise e disserte sobre esse
circuito de proteção, apresentando seu circuito esquemático.
Dica: O esquemático da placa como um todo pode ser encontrado na própria

página da Arduino, e ao longo da internet existem boas explicações desse
circuito.
5 O movimento chamado Hardware Livre vem crescendo pelo mundo e

também no Brasil. Por aqui são vistos vários projetos interessantes, que
possuem uma aplicação e resolvem um problema real da sociedade. Neste
contexto, acesse a página https://hardwarelivreusp.org/projetos/, escolha
um projeto de hardware livre e disserte sobre ele. Apresentes aspectos sobre
o hardware utilizado, funcionamento do código escrito e as suas limitações.
107
108
UNIDADE 2
TÓPICO 3 —
CONFIGURANDO E CONHECENDO A IDE DO ARDUINO
1 INTRODUÇÃO
Assim como o conhecimento do hardware, o uso de um bom ambiente
de programação auxilia muito o desenvolvimento de novos projetos. De forma
simples, poderíamos criar um arquivo do bloco de notas, por exemplo, e começar
a digitar ali o código que seria enviado ao microcontrolador. Com bastante esforço
e o auxílio de um compilador, esse código poderia ser enviado ao dispositivo e
teríamos a aplicação funcionando. Contudo, essa forma de desenvolvimento não
é prática, não existe um apoio ao programador no sentido de organizar o código
e reunir as ferramentas necessárias. É nesse sentido que surgem os Ambientes de
Desenvolvimento Integrado, ou IDE, do inglês. Esses programas reúnem todas
as ferramentas como editor de código, compilador e gerador de código em um
mesmo lugar, possibilitando ao programador um desenvolvimento mais ágil da
aplicação.
Para facilitar a vida dos usuários, o Arduino possui uma IDE própria
utilizada para programar as placas de desenvolvimento. O software permite a
criação de sketches, que são basicamente os códigos enviados a placa. Os sketches
são programados utilizando uma linguagem própria, baseada fortemente na
linguagem C++ (de forma geral tudo que vimos de C++ poderá ser utilizado
dentro da IDE). Dentro da IDE não há a necessidade de se referir a estrutura
interna do microcontrolador, não existe a necessidade de configurar registradores
individualmente. Antes do sketch ser enviado à placa de desenvolvimento, ele é
inicialmente convertido para a linguagem C e, em seguida, o compilador transfere
para a linguagem de máquina (SOUZA, 2013b).
Devido à importância da IDE para o desenvolvimento de novos projetos,

veremos nesse tópico como realizar a configuração correta desse software e a
conexão do Arduino ao computador. Além disso, estudaremos como as coisas
funcionam dentro da IDE e quais as ferramentas de software estão disponíveis pais
ajudar o desenvolvedor. Aprenderemos a utilizar as principais delas e veremos
como importar bibliotecas dentro da própria IDE. Para finalizar, enviaremos
ao Arduino Uno nosso primeiro sketch, que apesar de simples irá marcar o
desenvolvimento de vários outros projetos que ainda veremos nesse livro.
109
2 INSTALAÇÃO E CONFIGURAÇÃO DA IDE

Na prática, a IDE do Arduino é um software que instalamos no
computador, onde é possível escrever o código, realizar a verificação de erros e
enviá-lo ao Arduino. Uma vez enviado, o Arduino começará a se comportar da
forma que programamos, executando a leitura de sensores, cálculos matemáticos,
acionamento de motores, LED, ou quaisquer outras das imensas aplicações
possíveis.
Nessa seção nos concentraremos em instalar e configurar corretamente

a IDE do Arduino para as atividades seguintes. A princípio a instalação será
realizada no sistema operacional Windows 10, podendo ser utilizada as mesmas
configurações para os demais sistemas.
O primeiro passo é realizar o download da IDE no site da Arduino: https://

www.arduino.cc/en/software. Na página principal, selecione o arquivo Windows
(Win 7 and newer) e aguarde até que o download inicie. Logo em seguida abra o
arquivo baixado. A Figura 9 apresenta exatamente os passos descritos.
FIGURA 9 – PÁGINA DE DOWNLOAD DA IDE DO ARDUINO
FONTE: <https://www.arduino.cc/en/software>. Acesso em: 21 maio 2021.
Ao abrir o arquivo de instalação, simplesmente aceite todas opções e

aguarde o fim da instalação. Ao final, a mensagem “completed” deve aparecer na
tela, conforme a Figura 10.
110
TÓPICO 3 — CONFIGURANDO E CONHECENDO A IDE DO ARDUINO
FIGURA 10 – MENSAGEM INDICANDO QUE A INSTALAÇÃO FOI CONCLUÍDA
A partir daí, basta clicar no atalho gerado na Área de Trabalho do

computador e finalmente acessar a IDE do Arduino. A Figura 11 apresenta, de
forma geral, o visual do software e os principais recursos.
FIGURA 11 – INTERFACE DA IDE DO ARDUINO
De forma geral, a IDE do Arduino possui um design bem “enxuto”

possibilitando ao programador ver, em um primeiro momento, apenas os recursos
mais importantes. Na barra de ferramentas, por exemplo, temos os comandos
para verificar e fazer o upload do código para o Arduino, seguido dos botões para
criar um novo sketch, abrir um já existente ou salvar o atual. Logo a seguir tem-se
o nome do sketch, que também funciona como um sistema de abas, facilitando
a visualização de mais de um sketch em uma mesma janela. Temos então a área
para escrita dos códigos e finalmente uma caixa de comandos onde é exibido
111
o feedback das operações. É aí que é apresentado, por exemplo, se o envio do

sketch por Arduino teve sucesso. O menu suspenso da aplicação oferece ainda
uma série de opções como importar bibliotecas, configurar uma placa e outros
recursos que veremos adiante. Por fim, a lupa no canto superior direito abre o
Monitor Serial, outra ferramenta que veremos ainda nesse tópico.
3 CONECTANDO O ARDUINO
Como sabemos, as placas Arduino se comunicam com o computador
através de um cabo USB fornecido pelo próprio fabricante. Apesar da conexão não
ser nada complicada, na primeira vez que conectamos o Arduino ao computador
precisamos realizar um procedimento, tanto no computador como na IDE do
Arduino para que tudo funcione bem. Exploraremos essa configuração neste
subtópico.
A primeira coisa que precisamos fazer após conectar o Arduino Uno

no computador é instalar os drivers do mesmo. É bem provável que a janela
apresentada na Figura 12, apareça assim que a conexão for feita. A partir daí
basta clicar “Instalar” e deixar que o Windows faça o resto. Caso a janela da
Figura 12 não apareça será necessário verificar o Gerenciador de Dispositivos
do Windows. Procure na seção Portas (COM e LPT), lá deve estar uma porta
chamada Arduino UNO (COMxx). Clique o botão direito do mouse e selecione
a opção “Atualizar drive”. A partir daí selecione a opção "Procurar software de
driver no computador". Vá até a pasta "drivers" dentro do diretório do Arduino,
e selecione o arquivo "arduino.inf".
FIGURA 12 – JANELA DE INSTALAÇÃO DOS DRIVERS
Com os drivers instalados, o computador já está hábil para identificar e se

comunicar com o Arduino. Devemos agora configurar a IDE para fazer o mesmo.
O primeiro passo é selecionar a placa que vamos utilizar (Figura 13). Depois,
112
basta selecionarmos a porta ao qual o Arduino Uno está conectado. No caso da

Figura 14, o Arduino Uno se conectou a porta COM5, contudo, a conexão pode
acontecer também em outras portas, dependendo do computador.
FIGURA 13 – SELECIONANDO A PLACA ARDUINO A SER CONECTADA
Outras configurações como Upload Speed, CPU Frequency, e demais, não

precisam ser alteradas. A própria IDE identifica esses valores a partir da placa
selecionada e as configura. Feito o passo a passo apresentado nessa seção temos
tudo pronto para programar e enviar os primeiros sketches para o Arduino.
Contudo, é interessante que conheçamos primeiro a estrutura de um programa na
IDE do Arduino e uma ferramenta bastante importante para o desenvolvimento,
antes de começarmos.
113
FIGURA 14 – SELECIONANDO A PORTA AO QUAL O ARDUINO UNO ESTÁ CONECTADO
4 FUNÇÕES SETUP() E LOOP()

Talvez a única grande diferença entre a linguagem de programação
do Arduino e o C++ puro que iremos notar nessa fase inicial é a presença das
funções setup() e loop() como forma de estruturar o código em vez da tradicional
função main(). O restante do conhecimento adquirido como operadores lógicos
e relacionais, estruturas de repetição, funções, e os demais, pode ser utilizado na
IDE do Arduino sem problemas.
As funções setup() e loop() dividem o sketch em uma parte de configuração,

que se repete apenas uma vez durante a execução do código e em um loop que
é executado indefinidamente enquanto o Arduino estiver ligado. Dessa forma,
dentro da função setup() devemos colocar todas as configurações necessárias.
Aí entra a definição de pinos como entrada ou saída, configuração do monitor
serial e tantos outros. Já na função loop() fica o código que vai ser executado
repetidamente. Devemos aguardar que alguém aperte um botão para aí acender
um LED? O código para executar essa função ficaria no loop().
Acima da função setup() podemos ter ainda as diretivas do código como:

inclusão de bibliotecas e a definição de constantes. Outras funções criadas pelo
próprio programador também devem ficar assim da função setup(), assim se torna
possível chamar essas funções dentro do setup() ou mesmo do loop().
114
5 MONITOR SERIAL
O monitor serial é sem dúvida a melhor ferramenta, já que a IDE do
Arduino não possui debug, para verificação de erros em um código. O monitor
serial funciona como uma espécie de janela de comandos entre o Arduino e o
computador. Os dados inseridos pelo usuário através do teclado são enviados ao
Arduino via conexão USB. Da forma contrária, o Arduino pode enviar mensagens
que são exibidas na tela do computador.
NOTA
Debug são ferramentas utilizadas para encontrar erros dentro de um có-

digo. Em alguns deles, o código é executado passo a passo, sendo possível pausar a
execução, verificar os estados de variáveis e outros recursos. Na IDE do Arduino ainda
não temos esse tipo de funcionalidade, mas podemos utilizar o monitor serial de forma
improvisada para encontrar erros. Leia mais sobre os debugs em: https://www.hostgator.
com.br/blog/debug-desenvolvimento-web/.
O monitor serial, como já vimos, pode ser acessado com o Arduino

conectado na porta USB, através do ícone da lupa, apresentado na Figura 11. No
entanto, para começar a receber informações é necessário que seja realizado o
envio do sketch com a configuração adequada do monitor serial. A interface do
monitor serial é apresentada na Figura 15.
FIGURA 15 – INTERFACE DO MONITOR SERIAL APRESENTANDO AS PRINCIPAIS FUNCIONALI-

DADES
115
A configuração do monitor serial é feita através de funções padrão da IDE

do Arduino, não havendo necessidade de incluir as bibliotecas que as contém.
Veremos a seguir as funções necessárias para utilizar o monitor serial.
Serial.begin: A função Serial.begin(velocidade) inicia a conexão serial com

a placa Arduino, conectada ao computador. Como podemos ver, a função possui
um parâmetro que é a velocidade da conexão a ser estabelecida. Esse valor
depende da placa Arduino conectada. Para o Arduino Uno, utilizamos o valor
de 9600 baud. Sendo o baud a medida de quantos caracteres são enviados por
segundo.
Serial.print: A função Serial.print(valor) imprime no monitor serial o valor

da variável entre parênteses e mantem o cursor na mesma linha. Através dessa
função conseguimos observar o valor de determinadas variáveis ao longo da
execução do código. Uma variação dessa função é o Serial.println(valor), que além
de imprimir o valor no monitor serial pula uma linha.
Serial.available: A função Serial.available() retorna à quantidade de bytes

disponíveis para serem lidos. Caso o valor de Serial.available() seja maior que zero,
temos a indicação de que algum valor foi recebido através da porta serial.
Serial.read: A função Serial.read() é usada para ler os dados que foram

digitados pelo usuário na linha de comando do monitor serial. Essa função não
requer nenhum parâmetro para ser chamada, mas retorna o valor enviado em
formato char.
No próximo subtópico, nós enviaremos o nosso primeiro sketch. O

programa desenvolvido servirá como exemplo de uso do monitor serial e da IDE
do Arduino.
6 ENVIANDO O PRIMEIRO SKETCH

Finalmente, vamos enviar o nosso primeiro sketch ao Arduino Uno. A
intenção aqui é utilizarmos esse primeiro código apenas como forma de ver na
prática tudo que aprendemos nesse tópico. Veremos outros projetos na Unidade
3, quando de fato começaremos a trabalhar com a totalidade de recursos do
Arduino Uno.
Inicialmente, vamos a descrição do algoritmo desenvolvido. Nosso sketch

irá aguardar até que o comando “on” seja enviado através do monitor serial.
Ao receber esse comando, o LED nativo do Arduino Uno será acesso. De forma
contrária, ao receber o comando “off” o mesmo LED será desligado. Sempre que
um comando for enviado, uma mensagem na tela será exibida com o comando
enviado e informando se o LED foi acesso ou não. Você consegue imaginar como
poderíamos implementar isso na IDE do Arduino? Sim? Então tira um tempo
para tentar antes de analisar o resultado, apresentado na Figura 16.
116
FIGURA 16 – PRIMEIRO SKETCH ENVIADO AO ARDUINO UNO
Antes de ver o resultado no monitor serial vamos analisar linha a linha o

que foi escrito. Inicialmente, temos a declaração da variável “dado” como sendo
do tipo char. O fato de termos declarado essa variável fora de qualquer função
significa que podemos chamá-la em qualquer momento. Quando declarada dessa
forma, dizemos que uma variável é global. Ao contrário, quando declarada dentro
de uma função dizemos que ela é local.
Na função setup() fizemos duas coisas: iniciamos a porta serial com a

velocidade correta do Arduino Uno e definimos o pino 13 como sendo um pino
de saída. No pino 13 do Arduino Uno é conectado um LED, que já existe na placa,
e que queremos controlar. Então, na prática, o que estamos dizendo é que o pino
conectado ao LED será utilizado para saída de dados.
Na função loop() é que temos a lógica do nosso código acontecendo. A cada

repetição do da função loop() é verificada se algo foi recebido pela porta serial. Isso
é feito através do bloco IF principal. Caso o retorno da função Serial.available() for
maior do que zero temos a indicação de que algo foi recebido. A partir daí o valor
recebido é lido pela função Serial.read() e impresso na tela pela função Serial.
println(dado). A seguir, são feitas duas verificações com relação ao dado recebido:
caso tenha sido recebido o char ‘1’, o LED é acesso e caso seja recebido o char ‘0’ o
LED é apagado, sendo os caracteres ‘1’ e ‘0’ são os equivalentes ao “on” e “off” que
117
planejamos na descrição do algoritmo. O acionamento do LED é feito através da

função digitalWrite(porta, valor) que envia um valor alto (5V) ou baixo (0V) para
o pino em que o LED está conectado.
Com tudo pronto, podemos enviar o código ao Arduino Uno. Para fazer
isso basta conectar o Arduino via USB e pressionar a tecla de Upload, na barra de
ferramentas. O status da operação de aparecer, conforme a Figura 16, como “Done
Uploading”.
Todo o funcionamento do código pode ser analisado através do monitor

serial. Os testes realizados são apresentados na Figura 17. Como é de se esperar,
ao enviar os valores 1 e 0 temos o acionamento e o desligamento do LED, contudo,
ao enviar um caractere aleatório nada acontece, além de simplesmente imprimi-
lo na tela.
FIGURA 17 – MONITOR SERIAL INDICANDO AS SAÍDAS DO SKETCH ENVIADO AO ARDUINO
As funções utilizadas nesse exemplo podem ser utilizadas em uma série

de outros projetos. Que tal começar a experimentar e criar os seus?
7 IMPORTANDO BIBLIOTECAS
Apesar da IDE do Arduino já vir com uma quantidade interessante de
funções integradas, que não necessitam de declaração para serem usadas, não é
difícil que tenhamos que incluir no código ou até mesmo no diretório do Arduino
novas bibliotecas. Neste subtópico veremos justamente sobre isso, como incluir
novas bibliotecas no diretório do Arduino e como declarar as que já existem.
Inicialmente, precisamos saber o que já existe de bibliotecas presentes

na IDE Arduino. Podemos ter acesso a essas bibliotecas através do diretório de
arquivos. O caminho padrão para esses arquivos é apresentado na Figura 18.
118
FIGURA 18 – DIRETÓRIO DE ARQUIVOS DO ARDUINO COM BIBLIOTECAS JÁ INTEGRADAS
Acessando essas pastas temos acesso ao código fonte de cada uma das
bibliotecas, bem como exemplos e outros arquivos de configuração. É através
dos exemplos que podemos visualizar como incluir cada uma das bibliotecas.
Por exemplo, abrindo o arquivo CardInfo.ino, apresentado na Figura 19, vimos
que para utilizar a biblioteca para leitura de cartões SD (cartão de memória)
precisamos incluir duas bibliotecas, que já estão instaladas, chamadas SPI.h e
SD.h.
FIGURA 19 – EXEMPLO DA BIBLIOTECA SD
119
Esse seria o melhor cenário, em que a biblioteca já está presente no

diretório Arduino e para utilizar bastaria incluí-la no código. Mas e se ela não
estivesse presente? Bem, aí precisaríamos instalá-la. Isso pode ser feito de duas
formas, conforme apresentado na Figura 20.
FIGURA 20 – INSTALANDO NOVAS BIBLIOTECAS
A primeira delas, e talvez a mais simples, é procurar no gerenciador de

bibliotecas (1ª opção da Figura 20). Clicando nessa opção é aberto um menu onde
é possível pesquisar pela biblioteca requerida e adicioná-la clicando no botão
“Instalar”. Ao completar o processo a biblioteca já estará disponível para ser
utilizada. A maioria dessas bibliotecas possui também exemplos que podem ser
consultados.
A segunda opção seria incluir um arquivo .zip com o código-fonte da

biblioteca. A instalação dessa forma é também muito simples, mas requer que o
arquivo .zip seja obtido de uma fonte confiável. Procure sempre pelo produtor
original da biblioteca ou pelo repositório de arquivos na internet.
Apesar da IDE do Arduino estar cheia de bibliotecas prontas, não temos

que necessariamente utilizá-las. Podem ser instaladas novas bibliotecas que
realizem a mesma função das já instaladas, ficando assim, a cargo do programador
sua utilização ou não.
120
A partir de agora temos todo conhecimento necessário para desenvolver

os primeiros projetos. A próxima unidade tratará justamente sobre isso, como
desenvolver soluções para problemas reais, utilizando o Arduino e ferramentas
de aprendizagem.
121
O ARDUINO ESTÁ SE TORNANDO O NOVO PADRÃO DA INDÚSTRIA?
Fábio Souza
A plataforma Arduino foi lançada em 2005, na Itália, com o objetivo de

facilitar a programação de microcontroladores por estudantes de design e leigos
em eletrônica. Foi baseada nos projetos Wiring e Processing. Lançada como um
projeto open source, rapidamente criou-se uma grande comunidade em volta
desse projeto. Com o passar dos anos o projeto evoluiu muito e hoje é usado
por diversas pessoas e empresas no mundo. Mas será que plataforma continua
apenas com o foco em leigos e estudantes?
Nesse artigo apresento como o Arduino está se tornando um padrão

quando se pensa em programação de microcontroladores, o posicionamento
da empresa Arduino atualmente e também o uso da plataforma para aplicações
industriais.
Hardware e Software do Arduino
As placas Arduino evoluíram muito desde 2005. Fiz um artigo em 2013

mostrando a evolução das placas até o Arduino UNO.
Placas Arduino Serial e Arduino Uno
FONTE: <https://bit.ly/3ydfGoB>. Acesso em: 16 jul. 2021.
As placas oficiais lançadas recentemente já não são placas simples

baseadas apenas em microcontroladores AVR. Elas geralmente possuem um
microcontrolador ARM Cortex M0+ e algum tipo de conectividade.
Por exemplo, a linha MKR é focada em conectividade para IoT possuindo

uma família que vai desde WIFI até comunicação celular:
122
Loja Arduino com diversas placas novas
Também foram lançadas novas placas Arduino Nano, agora com o foco
em conectividade.
Novas placas Arduino Nano
123
Outra novidade foi o lançamento da placa MKR VIDOR 4000, a primeira

placa Arduino oficial com FPGA:
Placa Arduino MKR VIDOR 4000
Com toda essa sequência de lançamentos de placas com recursos para IoT,
nota-se que a empresa Arduino está focando suas energias em prover hardware
para prototipagem rápida de soluções para Internet das coisas.
Em paralelo diversas bibliotecas estão sendo adicionadas, assim como a

integração de novas placas oficiais e de terceiros ao ecossistema. Hoje isso é feito
com poucos cliques na IDE sem a necessidade de configuração manual nas pastas.
Hoje também é possível programar as placas através de uma plataforma

on-line, que possui recursos similares da IDE off-line com a possibilidade de
compartilhamento de código de uma forma mais fácil.
A empresa Arduino também lançou uma plataforma de nuvem para

facilitar a visualização de dados:
Arduino IoT Cloud
124
Adoção do Arduino em escolas e empresas
Com a estabilização da plataforma, uma grande documentação aberta

disponível e a facilidade de acesso às placas, foi natural a adoção do Arduino
no ambiente acadêmico. Hoje muitas escolas e faculdades usam o Arduino com
ferramenta para ensino de programação, desenvolvimento de projetos e pesquisas.
O uso não se restringe apenas a áreas de tecnologias e nem em formação técnica.
O Arduino é usado desde o ensino de crianças até em pesquisas de doutorados.
No que diz respeito à formação técnica e de engenharia na área de sistemas

embarcados, há uma grande discussão sobre o uso do Arduino e a eficácia do
ensino de programação de sistemas embarcados de forma mais aprofundada, já
que a plataforma mascara diversos detalhes de arquitetura e programação. Fiz
um vídeo que discute sobre esse assunto:
Já do lado corporativo a plataforma Arduino está presente em prototipagem

e validação de ideias. Muitas Startups de hardware começam a validar as suas
ideias a partir de PoC feitos com Arduino ou placas similares aproveitando o
ecossistema disponível.
Projetos para aplicações industriais
Apesar do Arduino não ter sido concebido para aplicações industriais, hoje
é possível encontrar placas Arduino ou projetos feitos com base nos hardwares
de placas Arduino oficiais ou compatíveis, em ambientes industriais. Em alguns
casos pode ser preocupante o uso das placas Arduino em projetos que requerem
requisitos de segurança e imunidade a ruídos. Confira o artigo que aborda o Uso
de kits comerciais para desenvolvimento de produtos.
Em contrapartida muitos projetos estão surgindo a diversos projetos

baseados em Arduino voltados para aplicações industriais. Tais projetos são
desenhados para unir o ecossistema Arduino com a segurança e a confiabilidade
dos PLCs de nível industrial. Um desses projetos que deixo como exemplo, é o
CONTROLLINO:
Plataforma Controllino MAXI
125
Recentemente a Novus anunciou o DigiRail NXprog um módulo de I/O

programável compatível com a programação Arduino. Segundo a empresa o
módulo foi projetado para simplificar e modernizar a linguagem de programação
industrial.
DigiRail NXprog da Novus
Além dos projetos apresentados, muitas empresas hoje estão usando

o ecossistema Arduino para desenvolvimento dos seus projetos na indústria,
principalmente em pequenas automações e projetos customizados de pequenos
volumes.
Preocupações
Mas nem tudo são flores! Apesar das facilidades e recursos disponíveis
não dá para fazer e aprender tudo com Arduino.
Focando no ambiente de ensino de sistemas embarcados, é importante

não deixar que os alunos tenham a falsa sensação de aprendizagem, focando
apenas na aplicação final, o que geralmente acontece com o uso do Arduino. É
importante o entendimento da arquitetura, técnicas de programação, otimização,
depuração, etc. Infelizmente hoje os alunos estão ficando presos à plataforma e
não conseguem explorar os recursos do microcontrolador e até mesmo escolher o
melhor dispositivo para seus projetos.
126
Já no ambiente profissional e no desenvolvimento de projetos, é necessário

tomar cuidado com o uso de bibliotecas não eficientes e até mesmo o conflito
entre bibliotecas. Outro detalhe importante é o consumo desnecessário de
memória que a abstração pode oferecer, além de perda de performance, como
apresentado no artigo: Performance do digitalWrite() no Arduino. Durante a fase
de desenvolvimento há limitação em recursos, como debug por hardware. Outro
ponto preocupante é que as placa de desenvolvimento não foram feitas para
aplicação final, como é comum encontrar em muitas aplicações por aí.
Conclusão
O Arduino revolucionou e democratizou o uso de microcontroladores no

mundo. Hoje muitas pessoas conseguem ter o contato com a programação de
microcontroladores e conseguem fazer projetos incríveis, através da abstração e
facilidades que o Arduino traz. Com todas essas facilidades e recursos disponíveis,
muitas ideias estão sendo colocadas em práticas e sendo validadas rapidamente.
Há diversas empresas fornecendo hardware e softwares para o ecossistema.
Também estão surgindo diversas aplicações focadas na indústria ou automação
residencial.
Porém, é importante entender até que ponto os hardwares podem ser

usados para aplicações finais, e quando o Arduino pode ser explorado para
ensino de sistemas embarcados de forma eficiente.
FONTE: Adaptado de <https://www.embarcados.com.br/o-arduino-esta-se-tornando-o-padrao-

-da-industria/>. Acesso em: 16 jul. 2021.
127
RESUMO DO TÓPICO 3
• A IDE do Arduino é um programa de computador em que escrevemos as

instruções que serão enviadas a placa de desenvolvimento.
• Apesar da IDE do Arduino utilizar uma linguagem muito parecida com o

C++, os sketches possuem uma estrutura diferente de um programa C++
tradicional.
• A estrutura de um sketch envolve essencialmente duas funções; a setup() e a

loop(). Na primeira é realizada a configuração dos parâmetros necessários e na
segunda fica o código que é executado continuamente pelo Arduino.
• Apesar da IDE do Arduino não possuir ferramentas de debug, pode-se utilizar

o monitor serial para consultar o valor de parâmetros ou enviar dados ao
Arduino.
• O monitor serial é controlado através de funções que configuram a

comunicação, fazem o envio e o recebimento de dados através da comunicação
serial entre o Arduino e o computador.
• As bibliotecas que vêm por padrão na IDE Arduino estão longe de ser uma
lista exaurível, muitas outras presentes na Internet podem ser adicionadas,
acrescentando funcionalidades e possibilitando o trabalhar com deferentes
tipos de hardware.
CHAMADA

128
AUTOATIVIDADE
1 Sketch é o nome dado pela Arduino para os programas criados através

da sua IDE, e que são enviados para as placas de desenvolvimento,
normalmente através de uma conexão USB como o computador. Sobre a
estrutura do sketch, assinale a alternativa INCORRETA.
a) ( ) A divisão de cada sketch entre uma função setup() e outra loop()

possibilita uma melhor organização e um maior entendimento da
funcionalidade do código escrito.
b) ( ) Diferente da linguagem C++, que possui uma estrutura de código
baseado em uma função principal, o sketch possui duas funções uma
destinada para a configuração de parâmetros e outra para os códigos
que devem ser executados de forma continua pelo Arduino.
c) ( ) Nos sketches a declaração de variáveis deve ser feito exclusivamente
dentro de funções, ocasionando erros caso sejam declaradas fora.
d) ( ) Nos sketches as variáveis locais são variáveis que podem ser utilizadas
apenas dentro de uma determinada função.
2 O monitor serial é uma ferramenta da IDE do Arduino utilizada para a

comunicação entre o Arduino e o computador conectado. Através dele é
possível verificar o estado de variáveis, enviar dados ao Arduino, entre
outras possibilidades. Contudo, se faz necessária a configuração dessa
ferramenta dentro do código através de funções padrão do Arduino. Sobre
as funções para configuração do monitor serial dentro da IDE do Arduino,
associe os itens, utilizando o código a seguir:
I- Serial.begin(velocidade)
II- Serial.print(valor)
III- Serial.println(valor)
IV- Serial.available()
V- Serial.read()
( ) Retorna à quantidade de bits disponíveis para serem lidos.

( ) Imprime no monitor serial o valor da variável enviada como parâmetro,
mantendo o cursor na mesma linha.
( ) Inicia a conexão com a placa Arduino conectada, fornecendo como
parâmetro a velocidade da conexão.
( ) Imprime no monitor serial o valor da variável enviada como parâmetro,
pulando o cursor para a próxima linha.
( ) Realiza a leitura dos dados digitados pelo usuário na linha de comando
do monitor serial.

a) ( ) V – III – II – I – IV.
b) ( ) II – IV – I – V – III.
129
c) ( ) IV – II – I – III – V.
d) ( ) V – III – I – II – IV.
3 As bibliotecas são conjuntos de funções que podem ser utilizadas

diretamente, sem a necessidade de o programador saber o código que
as compõem. Na IDE do Arduino, existem bibliotecas padrão que são
destinadas a trabalhar com determinados tipos de tecnologia como: cartões
SD, WiFi, Ethernet, entre outros. A respeito do uso de bibliotecas dentro
da IDE do Arduino, classifique V para as sentenças verdadeiras e F para as
falsas:
( ) Algumas funções como as de uso do monitor serial, podem ser utilizadas

diretamente dentro do código, sem a necessidade de incluir as bibliotecas
correspondentes no código.
( ) Existe a necessidade de o programador utilizar as bibliotecas padrão do
Arduino, evitando assim um mal funcionamento do código como um
todo.
( ) Novas bibliotecas podem ser adicionadas diretamente pela IDE do
Arduino, seja através do gerenciador de bibliotecas ou de um arquivo
com extensão .zip.

a) ( ) V – F – F.
b) ( ) V – F – V.
c) ( ) F – V – F.
d) ( ) F – F – V.
4 Além de outras possibilidades, o monitor serial é capaz de controlar o

Arduino através dos dados enviados através da linha de comando. Sabendo
disso, crie um sketch que ao receber o caractere 1, deixe o LED (presente
na placa do Arduino Uno no pino 13) aceso por 1 segundo, ao receber o
caractere 2 deixe o LED acesso por 2 segundo e ao receber o caractere 3
deixe o LED acesso por 3 segundos.
Dica: utilize a função delay(milissegundos) para fazer com que o LED

permaneça ligado pelo tempo determinado antes de apagá-lo.
5 Os sketches do Arduino possuem uma estrutura própria que facilita a

escrita e visualização do código para os iniciantes. Neste contexto, explique
onde podem ser declaradas as funções, diretivas e variáveis dentro de um
sketch.
130
REFERÊNCIAS
CANALTECH. O que é open source? 2021. Disponível em: https://canaltech.
com.br/produtos/O-que-e-open-source/. Acesso em: 19 maio 2021.
DEBIAN. Debian Social Contract. 2004. Disponível em: https://www.debian.

org/social_contract.html#guidelines. Acesso em: 19 maio 2021.
DELGADO, A. L. N. Linguagem C++ - Notas de Aula. 2018. Disponível em:

https://www.inf.ufpr.br/ci208/NotasAula.pdf. Acesso em: 11 maio 2021.
DICIO. Lógica. 2021. Disponível em: https://www.dicio.com.br/logica/. Acesso

em: 10 maio 2021.
EMBARCADOS. Editorial: linguagens de programação para sistemas embar-

cados. 2015. Disponível em: https://www.embarcados.com.br/editorial-lingua-
gens-para-sistemas-embarcados/. Acesso em: 3 maio 2021.
PANOSSO, A. R. Linguagem de Programação C++. 2019. Disponível em: https://

www.fcav.unesp.br/Home/departamentos/cienciasexatas/alanrodrigopanosso/
apostilacpp_2019.pdf. Acesso em: 11 maio 2021.
SOUZA, F. Arduino UNO. 2013a. Disponível em: https://www.embarcados.

com.br/arduino-uno/. Acesso em: 20 maio 2021.
SOUZA, F. Introdução ao Arduino – Primeiros passos na plataforma. 2013b.

Disponível em: https://www.embarcados.com.br/arduino-primeiros-passos/.
Acesso em: 20 maio 2021.
SPECTRUM. Interactive: the top programming languages. 2020. disponível

em: https://spectrum.ieee.org/static/interactive-the-top-programming-langua-
ges-2020. Acesso em: 3 maio 2021.
VASCONCELLOS, I. L. B.; TAMARIZ, A. del R.; BATISTA, S. C. F. Apostila de

lógica de programação. 2019. Disponível em: https://educapes.capes.gov.br/
bitstream/capes/560827/2/Apostila%20-%20Curso%20de%20L%C3%B3gica%20
de%20Programa%C3%A7%C3%A3o.pdf. Acesso em: 11 maio 2021.
131
132
UNIDADE 3 —
DESENVOLVIMENTO DE PROJETOS
COM ARDUINO
• simular o Arduino de maneira prática e intuitiva utilizando o Tinkercad;

• entender os principais recursos nativos do Arduino, bem como desen-
volver projetos nessa área;
• conhecer os principais sensores e atuadores disponíveis no mercado;
• aprender os principais passos para o desenvolvimento de projetos ele-
trônicos, utilizando esse conhecimento para a criação de protótipos que
resolvem problemas reais;
PLANO DE ESTUDOS
apresentado.
TÓPICO 1 – SIMULANDO O ARDUINO ATRAVÉS DO TINKERCAD

TÓPICO 2 – EXPLORANDO RECURSOS NATIVOS DO ARDUINO
TÓPICO 3 – PROJETOS COM SENSORES E ATUADORES
CHAMADA

133
134
SIMULANDO O ARDUINO ATRAVÉS DO TINKERCAD
1 INTRODUÇÃO
O desenvolvimento de novas aplicações normalmente envolve uma
sequência de passos em que o projetista experimenta, altera e desenha as
funcionalidades que serão desenvolvidas. Esse é um processo trabalhoso,
que, muitas vezes, se desenrola através de várias tentativas. Antigamente,
cada tentativa deveria ser realizada através da montagem de um circuito, com
compras de equipamentos, soldagem, entre outros passos. Hoje, esse processo se
tornou mais prático através dos softwares de simulação. Através do software de
simulação é possível experimentar um determinado circuito, a fim de verificar
se ele atinge o resultado esperado, isso tudo sem a necessidade de adquirir nem
montar nenhum dos componentes.
Hoje, a simulação corresponde a uma etapa do desenvolvimento de

projetos de eletrônica. Nele, o projetista é capaz de ter uma aproximação da
realidade, enxergando como o circuito vai funcionar. Dessa forma, se otimiza
tempo, se economiza recursos e o projeto se desenvolve mais facilmente. No
desenvolvimento como microcontroladores, é necessário que esses softwares
sejam capazes de simular também o funcionamento desses dispositivos, recebendo
como entrada o código desenvolvido e simulando como o microcontrolador iria
se comportar. Softwares com essa característica normalmente têm um altíssimo
valor de mercado (veja a licença do Proteus, por exemplo) e podem não ser tão
amigáveis a iniciantes. Uma alternativa gratuita que vem se utilizada cada vez
mais é Tinkercad.
Neste tópico, nós estudaremos o funcionamento e a simulação de circuitos

no Tinkercad. Com ele podemos simplesmente simular o Arduino Uno e desenhar
todo o circuito que vai estar conectado a ele, e o melhor, completamente de
graça! Estudaremos essa ferramenta para que ao longo desta unidade possamos
explorar vários outros recursos do Arduino Uno e também desenvolver projetos
com aplicação real. Caso você não tenha um Arduino em casa, não tem problema,
o funcionamento das aplicações pode ser visto através do Tinkercad.
135
UNIDADE 3 — DESENVOLVIMENTO DE PROJETOS COM ARDUINO
2 PRIMEIROS PASSOS COM O TINKERCAD

Apesar do nosso interesse em utilizar o Tinkercad para a simulação de
circuitos, a ferramenta é bem mais do que isso. Outras aplicações do Tinkercad
incluem a modelagem 3D de objetos e o desenvolvimento de código. O mais
interessante é que tudo funciona pelo próprio navegador, sem a necessidade de
instalar nenhum programa. Dessa forma, a ferramenta consegue reunir de forma
prática e fácil o necessário para o desenvolvimento completo de novas soluções.
Imagine, no navegador você pode simular o circuito completo, visualizar o código
de forma lúdica em forma de blocos e ainda fazer a modelagem 3D de produtos.
Para começar a utilizar o Tinkercad, basta acessar a página tinkercad.com

e realizar o cadastro utilizando um e-mail confiável. É interessante conservar bem
esse acesso, pois todos os designs que serão desenvolvidos ficarão salvos nessa
conta, podendo ser acessados posteriormente.
Para garantir que estamos todos no mesmo ponto, ao completar o cadastro,

sua tela deve estar da mesma forma da apresentada na Figura 1.
FIGURA 1 – PÁGINA INICIAL DO TINKERCAD APÓS O CADASTRO DE USUÁRIO
A Figura 1 apresenta o menu para criação de novo projetos do Tinkercad

e para o acesso a lições, onde você, acadêmico, pode também aprender por conta
própria, utilizando o material que a plataforma dispõe. Sem mais delongas, para
começar a experimentar o Tinkercad basta clicar no botão “Criar novo Circuito”.
Ao clicar, você verá a interface de desenvolvimento pronta. Que tal, antes de
acompanhar a explicação, explorar por conta própria os recursos? Os principais
recursos são apresentados na Figura 2.
136
TÓPICO 1 — SIMULANDO O ARDUINO ATRAVÉS DO TINKERCAD
FIGURA 2 – INTERFACE DO TINKERCAD PARA DESENVOLVIMENTO DE CIRCUITOS
O desenvolvimento no Tinkercad funciona de forma bem simples.

Inicialmente são posicionados os componentes necessários, que serão simulados.
Cada um desses componentes deve ser conectado através de um fio, que é
representado simplesmente pela linha verde que vemos na Figura 2. No menu
superior esquerdo, cada componente pode ser ajustado em termos de orientação,
ou ainda excluído. É possível ainda alterar a cor do fio, possibilitando uma
compreensão melhor das ligações. Estando tudo pronto, a simulação pode ser
iniciada pelo botão verde em destaque no menu superior direito. Lá podemos
ainda acessar o código que vai ser enviado para o Arduino da simulação. Por
último, podemos visualizar também a lista de componentes da simulação,
facilitando assim a compra dos componentes para montagem do circuito real.
Como podemos perceber todo o desenvolvimento é bem intuito. O que não

vimos ainda é como utilizar o Tinkercad para simular o Arduino. Bem, simular o
Arduino é tão simples quanto incluir um componente. Só que nesse caso teremos
também que acessar a aba código, no menu superior direito, para incluir o código
que o Arduino deve executar. Vamos ver esse processo através de um exemplo.
Para simplificar, vamos criar um código que pisque um LED externo,

conectado ao pino 13 do Arduino, a cada 1 segundo. Caso você se lembre, o pino
13 é onde está conectado também o LED interno do Arduino Uno. Dessa forma,
quando acionarmos o LED externo estaremos acionando também o LED interno
da placa. Para abrir o exemplo no Tinkercad basta selecionar a seção “Arduino”
na aba de componentes e clicar no exemplo “Piscar”. A interface conforme a
apresentada na Figura 3 deve aparecer.
137
FIGURA 3 – EXEMPLO "PISCAR" PRESENTE NO TINKERCAD
Como se trata de um exemplo pronto do Tinkercad, ao clicar em

“Código” já temos o código para piscar o LED implementado. Como você vai
perceber ao clicar, o Tinkercad disponibiliza três tipos de formas de escrever o
código. A primeira seria em forma de blocos lógicos, onde cada bloco possui um
trecho de pseudocódigo. Você lembra dessa ferramenta? Esse formato facilita
bastante para quem não está muito habituado com linguagem de programação,
mas acaba limitando o usuário pelos blocos que estão disponíveis. A segunda
forma seria em forma de texto, que na prática seria o código em linguagem de
programação propriamente dita. Como você vai ver a sintaxe aqui é igual à da
IDE do Arduino, inclusive com as mesmas funções setup() e loop(). A última forma
combina as duas anteriores, ou seja, blocos mais texto. Desse modo, os blocos
que são acrescentados se transformam instantaneamente em código, sendo uma
boa forma de visualizar códigos mais complicados. Uma vez que já temos uma
certa familiaridade com linguagem de programação e com a IDE do Arduino o
ideal é continuar praticando, e usar o formato de texto para o desenvolvimento.
Além disso, nesse formato é possível baixar diretamente um arquivo .ino para
ser enviado ao Arduino real. Apesar disso, nada impede que você valide certos
trechos de código usando a forma de blocos.
Dito isso, podemos simplesmente iniciar a simulação. Assim, tanto o

LED externo como interno devem começar a piscar em intervalos de 1 segundo.
O interessante é que toda simulação é interativa, então é possível, durante
a simulação, clicar em botões, fazer ajuste de um potenciômetro, entre outras
coisas. Outro recurso interessante é a presença de um monitor serial, exatamente
igual ao presente na IDE do Arduino.
138
Daqui em diante vale experimentar por conta própria ou ver os exemplos

prontos do Tinkercad. Na aba “Galeria” (Figura 1) é possível acessar ainda
projetos criados por outras pessoas. Lembre-se, a melhor forma de aprender é
praticando.
3 AJUSTANDO PARAMÊTROS
Frequentemente estamos interessados em personalizar nossa simulação,
seja por um resistor que deve possuir um valor diferente de resistência, um
capacitor com um valor diferente de capacitância ou até um sensor que deve
possuir um valor padrão diferente. Tudo isso pode ser feito através do ajuste de
parâmetros que também está disponível no Tinkercad. Para alterar os parâmetros
de um componente basta clicar nele com o botão esquerdo do mouse. A Figura 4
apresenta o exemplo dos parâmetros de um capacitor.
FIGURA 4 – PARÂMETROS DO CAPACITOR NO TINKERCAD
Cada um dos parâmetros apresentados podem ser alterados e

consequentemente vão produzir um resultado diferente durante a simulação. Ao
contrário de outros simuladores, o Tinkercad permite alterar parâmetros também
durante a simulação.
Contudo, nem todo componente possui parâmetros relevantes para serem

alterados (sempre se pode alterar ao menos o nome do componente). Alguns
componentes em vez de parâmetros possuem estados que podem ser alterados
durante simulação. Veja o circuito da Figura 5, por exemplo.
139
FIGURA 5 – CIRCUITO COM INTERRUPTOR DESLIZANTE
Com o interruptor deslizante podemos alterar, durante a simulação, qual

LED que irá receber do Arduino o sinal para piscar. Como podemos observar, o
interruptor deslizante não possui parâmetros, mas pode ter o seu estado alterado
em tempo real.
Estão presentes ainda no Tinkercad quatro instrumentos fundamentais

para eletrônica: o osciloscópio, o gerador de função, o multímetro e uma fonte de
energia. Esses instrumentos possuem tanto parâmetros como estados que podem
ser alterados durante a simulação. Devido a sua importância cada um desses
instrumentos é detalhado a seguir com os parâmetros a serem preenchidos no
Tinkercad.
3.1 OSCILOSCÓPIO
O osciloscópio é um instrumento de fundamental importância em qualquer
laboratório de eletrônica. Basicamente, ele permite a visualização de sinais, além
de quantificar os parâmetros como: frequência, valor máximo, valor eficaz, valor
médio, entre outros parâmetros (MATTEDE, 2021). No Tinkercad, o osciloscópio
possui apenas um canal, o que significa que só podemos visualizar um sinal
140
por componente (pode ser incluído mais de um osciloscópio por simulação). O

único parâmetro que se pode alterar é o tempo por divisão do gráfico, conforme
apresentado na Figura 6.
FIGURA 6 – OSCILOSCÓPIO NO TINKERCAD APRESENTANDO UMA ONDA TRIANGULAR
3.2 GERADOR DE FUNÇÃO

Na prática o gerador de função é um equipamento capaz de gerar ondas
de várias formas, existindo botões que trocam de um formato para outro. No
Tinkercad, o gerador de função é capaz de gerar ondas quadradas, triangulares e
senoidais. São previstos parâmetros que controlam a amplitude da onda gerada,
a frequência e o deslocamento da onda no eixo y. A Figura 7 apresenta o símbolo
do gerador de função com os parâmetros passíveis de ajuste.
FIGURA 7 – GERADOR DE FUNÇÃO DO TINKERCAD COM OS PARÂMETROS PARA AJUSTE
Cada um dos parâmetros pode ser alterado também durante a simulação

através dos botões presentes no próprio gerador de funções.
141
3.3 MULTÍMETRO
O multímetro é um equipamento facilmente encontrado em laboratórios de
eletrônica, tendo a capacidade de medir diversos valores, sendo os mais comuns:
tensão, corrente e resistência. O multímetro do Tinkercad mede exatamente os
parâmetros citados anteriormente, havendo a possibilidade de mudar de um tipo
de medição para outro durante a simulação. A Figura 8 apresenta o símbolo do
multímetro junto aos parâmetros que podem ser alterados.
FIGURA 8 – REPRESENTAÇÃO DO MULTÍMETRO NO TINKERCAD
3.4 FONTE DE ENERGIA

A fonte de energia é talvez um dos instrumentos mais necessários para
eletrônica. Especialmente, as fontes controladas, ou seja, que podemos alterar o
valor de saída da tensão e corrente, são fundamentais para experimentação. A
fonte de tensão do Tinkercad é controlada e oferece valores de tensão que vão
de 0V a 30V e 0A a 5A em corrente contínua. Esses níveis de tensão e correntes
são essenciais para alimentar pequenos motores elétricos ou outras cargas que
não possam ser alimentadas diretamente pelo Arduino, por conta da limitação
de corrente. Assim como o gerador de função, os parâmetros da fonte de energia
podem ser alterados durante a simulação e sem a necessidade de desconexão
do dispositivo. A Figura 9 apresenta a fonte de energia do Tinkercad junto aos
parâmetros que podem ser alterados.
FIGURA 9 – REPRESENTAÇÃO DA FONTE DE ENERGIA DO TINKERCAD COM OS PARÂMETROS

CONTROLÁVEIS
142
4 DEPURADOR
Algo que não encontramos na IDE do Arduino é um depurador (ou debug)
para verificação de erros dentro do código. Trabalhando unicamente com a IDE
do Arduino teríamos que verificar os erros através do monitor serial o que nem
sempre é trivial. Já no Tinkercad é possível encontrar essa ferramenta. Veremos
como ela funciona nesse tópico.
Basicamente, o depurador do Tinkercad é capaz de criar pausas durante

a execução da simulação, onde é possível ver o valor das variáveis de interesse. É
como se parássemos tudo para olhar dentro da memória do Arduino. Para utilizar
esse recurso é bem simples. Basta clicar no botão de código e selecionar o formato
de texto (não é possível utilizar em outros formatos). Para criar uma pausa basta
clicar no número da linha onde o código deve ser interrompido e clicar em iniciar
a simulação. Ao chegar no ponto marcado a simulação será interrompida e a
linha selecionada ficará marcada. Aí é só passar o mouse em cima da variável
e ver o valor atual. Vamos ver isso na prática através de um exemplo. Vamos
pegar o exemplo “Piscar” apresentado na Figura 3 e inserir uma variável global
chamada de “a”, a cada iteração, ou seja, sempre que o LED piscar essa variável
será incrementada em 2. Inserindo uma interrupção na linha em que a variável é
incrementada tem-se o resultado da Figura 10.
FIGURA 10 – INTERRUPÇÃO DO CÓDIGO NA LINHA MARCADA E COM O VALOR DA VARIÁVEL

"A" SENDO APRESENTADO
Observe que ao fim da primeira iteração temos o valor de “a” sendo igual
a dois, como era esperado. Para continuar com a execução do código basta clicar
na seta na parte superior direita da tela.
143
Em programas simples o depurador pode não parecer algo muito

necessário, mas à medida que um código vai crescendo em tamanho e
complexidade, um depurador facilita bastante a análise rápida de erros.
5 ADICIONANDO BIBLIOTECAS
Como já sabemos, em alguns momentos é necessário incluir bibliotecas
dentro de um determinado código, a fim de utilizar as funções que estão dentro
desta. Normalmente, em aplicações para microcontroladores, uma biblioteca está
associada a utilização de um determinado componente, como o cartão SD que
vimos no tópico anterior. Incluir a biblioteca SD.h no nosso código permite a
utilização de funções prontas para leitura e gravação de dados nesses cartões. No
Tinkercad também são disponibilizadas bibliotecas que já estão instaladas dentro
da IDE e que podem ser incluídas diretamente. Diferente da IDE do Arduino
no Tinkercad não é possível instalar novas bibliotecas. Contudo, todos os
componentes que podem ser utilizados dentro da aplicação possuem a biblioteca
associada. A Figura 11 apresenta as bibliotecas disponíveis e também a sequência
para adicionar uma biblioteca ao código.
FIGURA 11 – SEQUÊNCIA PARA ACESSAR, INCLUIR E VISITAR A DOCUMENTAÇÃO DE UMA DAS

BIBLIOTECAS DISPONÍVEIS NO TINKERCAD
144
Através do botão incluir não existe a necessidade de declarar a biblioteca

manualmente, a diretiva #include junto ao nome da respectiva biblioteca
aparecem de forma automática no início do código. É possível acessar ainda a
documentação de cada uma das bibliotecas. É através dessa documentação que
se tem acesso aos parâmetros e retorno de cada função, sendo fundamental sua
análise.
6 EXEMPLO PRÁTICO
Daqui para a frente utilizaremos o Tinkercad para visualizar como alguns
dos recursos do Arduino funcionam na prática. A nossa abordagem daqui em
diante vai partir de um estudo mais específico dos recursos do Arduino para
um estudo macro, através de projetos que resolvem problemas reais do dia a
dia. A fim de ir se acostumando com tudo isso, vamos dedicar essa seção para
apresentar exemplo prático e ver como uma simulação de forma geral funciona.
O primeiro passo para desenvolver qualquer projeto é saber o que

precisamos realizar. Normalmente isso vem com uma descrição do que o circuito
deve realizar. Como primeiro exemplo, queremos criar uma campainha eletrônica,
ou seja, ao pressionar um botão teremos um sonorizador que vai emitir som por
um determinado período de tempo. Entendendo bem a descrição podemos partir
para o segundo passo que seria a montagem da simulação. Com o Tinkercad
aberto temos que escolher quais componentes vamos utilizar. Obviamente, vamos
incluir um Arduino pelo apelo didático do projeto. Contudo, na prática, vale a
pena analisar se o problema não pode ser resolvido sem um microcontrolador,
justamente pelo custo que esse componente acrescenta no orçamento do projeto.
Vamos precisar também de um sonorizador, um botão e eventualmente de algum
resistor.
Com os componentes escolhidos temos que definir quais pinos do Arduino

serão utilizados. Tanto o botão quanto o sonorizador podem ser conectados em
pinos digitais, então podemos escolher quaisquer dois que estejam disponíveis.
Além disso, precisamos saber que para a montagem do botão é preciso adicionar
um resistor de pull-down. Esse componente garante que os estados zero e um
sejam lidos corretamente pelo Arduino, evitando oscilação de tensão na entrada
do pino. Normalmente, um resistor com valor de 10k é suficiente para garantir o
nível de tensão correto. A seguir podemos partir para a montagem do circuito no
Tinkercad. A Figura 12 apresenta essa montagem.
145
NOTA
Ao contrário do que parece, um resistor de pull-down não diz respeito a

um tipo específico de resistor e sim a função de um resistor comum em um circuito de
acionamento. Além do resistor de pull-down, existe também o pull-up, a diferença entre eles
está basicamente na posição em relação à chave. O artigo em: https://autocorerobotica.
blog.br/resistores-pull-up-e-pull-down-como-funcionam/ apresenta o circuito para essas
duas configurações assim como uma explicação detalhada do seu funcionamento.
FIGURA 12 – MONTAGEM DO CIRCUITO DA CAMPAINHA
Montagem realizada, podemos prosseguir com o desenvolvimento do

código para o Arduino. Já sabemos o que deve ser feito, então podemos, com um
pouco de trabalho, traduzir a descrição para o código apresentado na Figura 13.
FIGURA 13 – CÓDIGO DESENVOLVIDO PARA O PROJETO DA CAMPAINHA
146
Iniciamos o código declarando os pinos 5 e 8 como entrada e saída de

dados, respectivamente. O pino 5 é onde se receberá o sinal do botão enquanto
o pino 8, a saída para o sonorizador. Na função loop(), o bloco IF verifica
continuamente se o botão foi pressionado. Quando isso acontece a função tone()
reproduz um som na frequência de 440 Hz no sonorizador. Na prática, tem-se o
funcionamento da campainha como esperávamos, ou seja, ao pressionar o botão
um som é reproduzido.
NOTA
A função tone() está entre as funções que já estão disponíveis quando

trabalhamos com o Arduino, ou seja, não existe a necessidade de declaração da biblioteca
ao qual ela está incluída. Para se obter mais informação a respeito dessas funções pode-
se utilizar a própria documentação do Arduino. A documentação da função tone(), por
exemplo, está em: https://www.arduino.cc/reference/pt/language/functions/advanced-
io/tone/, onde as demais podem também ser visualizadas.
Verificado que tudo está funcionando de acordo com o previsto, o projeto é

então montado fisicamente, com os componentes já estabelecidos e com o mesmo
código desenvolvido pronto para ser enviado ao Arduino real.
O passo a passo que utilizamos para o projeto da campainha eletrônica

pode ser abstraído em uma abordagem geral de desenvolvimento de projetos.
Confira o passo a passo a seguir.
1. Definição do escopo do projeto: nessa etapa é definido o que o circuito

eletrônico deve realizar. O resultado dessa etapa é uma descrição, fluxograma ou
pseudocódigo detalhando o funcionamento do projeto.
2. Escolha dos componentes: aqui é avaliado que componentes eletrônicos

devem ser utilizados para o desenvolvimento do projeto, bem como os pinos e
recursos em geral do Arduino que serão utilizados.
3. Montagem da simulação: essa etapa envolve a conexão dos componentes

na simulação bem como a escrita do código que o Arduino utilizará para a
execução do funcionamento pretendido.
4. Avaliação dos resultados: os resultados obtidos são então avaliados a

fim de estabelecer se o projeto está apto ou não para ser montado fisicamente.
147
RESUMO DO TÓPICO 1
• A simulação é uma etapa importante do desenvolvimento de projetos de

eletrônica, sendo fundamental a sua realização antes da montagem física dos
componentes.
• O Tinkercad realiza a simulação de circuitos de forma gratuita, simples e

intuitiva, sendo possível a mudança de parâmetros, desenvolvimento de
códigos para o Arduino e até mesmo o uso de um depurador, recurso que
não existe na IDE do Arduino.
• O Tinkercad conta com a simulação de quatro instrumentos: o osciloscópio,

o gerador de função, o multímetro e a fonte de energia. Esses equipamentos
estão presentes no dia a dia dos laboratórios de eletrônica e podem ser
utilizados durante as simulações.
• O desenvolvimento de projetos em eletrônica segue quatro passos principais,

que seriam basicamente: a definição do problema, a escolha dos componentes,
a simulação e a avaliação dos resultados.
148
AUTOATIVIDADE
1 O Tinkercad é uma solução oferecida pela empresa Autodesk, onde o

usuário pode desenvolver projetos de modelagem 3D e simulação de
circuitos. A partir dos recursos disponíveis para simulação de circuitos,
a) ( ) Através do Tinkercad é possível simular o Arduino e outros

microcontroladores além de desenvolver códigos para serem
executados nesses dispositivos.
b) ( ) Através do menu Galeria é possível visitar projetos criados por outras
pessoas dentro da plataforma, sendo assim uma boa oportunidade
para iniciantes aprenderem a partir da análise de projetos já existentes.
c) ( ) A alteração de parâmetros pode ser realizada através da janela que
se abre ao clicar no componente com o botão esquerdo do mouse,
contudo, nem todos os componentes possuem parâmetros relevantes a
serem alterados.
d) ( ) O depurado presente no Thinkercad é capaz de identificar de forma
instantânea os erros que estão impedindo o código de compilar, assim
mais eficiente que a IDE do Arduino.
2 Os equipamentos de laboratório fazem uma grande diferença quando

os primeiros protótipos estão sendo montados em bancada. Durante
a simulação, é possível utilizar também esses equipamentos, estando
disponíveis no Tinkercad quatro opções de equipamentos. A respeito da
função desses equipamentos para o desenvolvimento de projetos, associe
os itens, utilizando o código a seguir:
I- Osciloscópio.
II- Gerador de Função.
III- Fonte de Energia.
IV- Multímetro.
( ) Equipamento capaz de gerar ondas com formatos, valores, frequência e

deslocamento diferentes.
( ) É capaz de suprir outros equipamentos com valores variáveis de tensão e
corrente.
( ) Possui a capacidade de medir valores como tensão, corrente e resistência,
apresentando o resultado através de um display.
( ) Permite a visualização do formato de ondas além de quantificar parâmetros
como frequência, valor máxima, eficaz e médio.

a) ( ) III – II – IV – I.
b) ( ) II – III – IV – I.
149
c) ( ) I – III – II – IV.
d) ( ) II – I – IV – III.
3 O desenvolvimento de projetos é uma atividade criteriosa que deve ser

realizada através de uma sequência de passos específicos, com a finalidade
de reduzir custos e evitar desperdício de recursos. Com base nas etapas
para o desenvolvimento de projetos eletrônicos, analise as sentenças a
seguir:
I- O primeiro passo para o desenvolvimento de projetos é entender o que o

circuito deve realizar, transcrevendo essa informação no código que será
executado pelo microcontrolador.
II- Além de escolher os componentes é necessário se certificar que o
microcontrolador terá portas suficientes para interagir com todos os
componentes necessários.
III- Após a montagem da simulação o circuito está pronto para ser montado
fisicamente. Dessa forma é possível utilizar a mesma lista de componentes
da simulação para a montagem real.

a) ( ) As sentenças I e III estão corretas.
b) ( ) Somente a sentença III está correta.
c) ( ) As sentenças II e III estão corretas.
d) ( ) Somente a sentença II está correta.
4 Assim como na IDE do Arduino, no Tinkercad também é possível

acrescentar bibliotecas em código sem a necessidade instalá-las. Uma das
bibliotecas disponíveis é a LiquidCrystal.h, utilizada para o controle de
displays LCD pelo Arduino. Acesse a documentação dessa biblioteca e
explique o funcionamento de pelo menos três funções contidas nela.
5 Já muito cansado de trabalhar em seu projeto, um estudante de Engenharia

Elétrica cometeu o erro de atribuir a uma variável qualquer à leitura
analógica de um pino digital. Como sabemos, essa ação vai resultar em
um valor incorreto, pois um pino digital não possui conversor AD. Para
piorar a situação, o Tinkercad não é capaz de perceber esse erro, deixando
o aluno desesperado, sem saber de onde vem o erro. Para ajudar o colega,
explique como o depurado pode ser utilizado para verificar que a variável
em questão não está recebendo o valor que devia.
150
EXPLORANDO RECURSOS NATIVOS DO ARDUINO
1 INTRODUÇÃO
Como forma de interagir com o meio físico, o Arduino deve ser dotado
de recursos que possibilitem, o acionamento de motores, a leitura de sensores,
a comunicação entre dispositivos, entre outras utilidades. Esses recursos estão
disponíveis de forma nativa, ou seja, não possuem necessidade de nenhum
hardware adicional, nem mesmo da instalação de novas bibliotecas.

Ao longo da nossa jornada neste livro didático, vimos de forma superficial
muitos desses recursos que o Atmega328 possui e que consequentemente pode-
se utilizar no Arduino Uno. No entanto, boa parte deles foram apenas citados
e nunca nos aprofundamos a ponto de entendê-los e utilizá-los. Falamos, por
exemplo, dos pinos de entrada e saída, conversores analógico-digital, saídas
PWM e outros desses recursos, que são fundamentais para utilizar o Arduino
Uno na sua totalidade e também para ampliar o leque de projetos que se pode
desenvolver. Agora com Tinkercad, o aprendizado desses recursos se torna mais
didático, porque poderemos visualizar como tudo funciona, não se restringindo
apenas a teoria.
Através de uma breve explicação teórica e de exemplos no Tinkercad,

veremos nesse tópico os principais recursos para o desenvolvimento de projetos no
Arduino. Veremos como as entradas e saída digitais são utilizadas para interagir
com o mundo externo, como os conversores analógico-digitais realizam a leitura
de variáveis físicas, como as saídas PWM funcionam, como a transmissão serial é
utilizada para comunicação entre dispositivos, e, finalmente, como os timers são
utilizados para contagem de tempo dentro do microcontrolador.
2 ENTRADAS E SAÍDAS DIGITAIS

Durante o estudo do próprio Atmega328 e também do Arduino Uno
vimos que existem pinos que funcionam como entradas e saídas de dados. Essa
característica do pino é configurada via código, permitindo a leitura ou a geração
de níveis lógicos baixos e altos. Qualquer pino em modo de entrada de dados,
permitirá que o seu nível lógico seja lido, enquanto em modo de saída de dados,
permitirá que um nível lógico seja gerado.
151
Como já apresentado anteriormente, inclusive através de um exemplo, as

entradas e saídas digitais podem ser utilizadas para ler um estado de um botão,
para acionar um LED, entre várias outras soluções. A configuração dos pinos
digitais é realizada através de funções, já disponíveis no Arduino e apresentadas
a seguir.
pinMode: A função pinMode (pino, modo) é responsável pela configuração

de um determinado pino como entrada ou saída de dados. Assim os pinos são
referidos através da sua identificação no Arduino e o modo é definido como
sendo OUTPUT (saída) ou INPUT (entrada). Baseado na escolha dos modos uma
das duas funções a seguir pode ser utilizada.
digitalWrite: Utilizada no modo de saída de dados, a função

digitalWrite(pino, valor) “escreve”, ou melhor, gera no pino especificado o valor
digital previsto, podendo ser um valor HIGH (alto) ou LOW (baixo).
digitalRead: Caso o modo de entrada de dados tenha sido selecionado,

é possível utilizar a função digitalRead(pino) para a obtenção do valor digital no
pino. Assim o retorno da função pode ser um valor HIGH ou LOW.
Como a utilização das entradas e saídas digitais já foi abordado durante

esse livro, é recomendado uma revisão dos exemplos já apresentados, agora com
um olhar mais crítico e específico desse recurso em especial. Revisite o exemplo
apresentado durante a explicação do depurador (Tópico 1, subtópico 4) e o da
campainha eletrônica (Tópico 1, subtópico 6).
A grande limitação aqui é que os pinos digitais só devem possuir

idealmente dois valores, alto e baixo, 0V ou 5V. Se quiséssemos ler o valor de
um sensor de temperatura, por exemplo? Bem, aí teríamos que partir para os
conversores analógicos, como será apresentado na próxima seção.
3 CONVERSORES ANALÓGICO-DIGITAIS
Na natureza, a maioria dos valores variam de forma analógica. Entre os
exemplos mais conhecidos podemos citar a temperatura, pressão, velocidade e
a luminosidade. Dentro da perspectiva de interação do Arduino com o meio, o
mesmo deve ser capaz também de ler e interpretar esses resultados, sendo utilizado
para isso um conversor analógico-digital interno. O conversor analógico-digital
(AD) nada mais é do que um circuito presente no Atmega328 capaz de realizar
a leitura de valores analógicos, a partir da conversão desses em valores digitais.
Apesar de na prática, a leitura de um valor analógico ser muito simples por conta
da facilidade que o Arduino proporciona, vale a pena entender como esse recurso
funciona por detrás dos panos.
152
TÓPICO 2 — EXPLORANDO RECURSOS NATIVOS DO ARDUINO
Cada conversor AD possui uma quantidade de bits, que indicam a

resolução do valor convertido, e um valor de referência, que representa o valor
máximo que a medição analógica pode assumir. No caso do Arduino, temos
10 bits e uma tensão de referência de 5V em operação nominal. Desse modo, a
resolução da medição é dada pela Equação 1.
(1)
Onde, Vref, representa a tensão de referência, e n a quantidade de bits de

referência.
Na prática, isso significa que um valor analógico é aproximado através de

degraus (incrementos) de 4,88 mV, sendo esse também o menor valor que pode
ser medido pelo Arduino, com essa tensão de referência. Assim uma variável que
possui idealmente um valor de 4,95V é aproximado pelo Arduino através de 1014
degraus de 4,88 mV cada, sendo apresentado o valor de 4,948V para o usuário.
Como pode-se perceber pela Equação 1, quanto maior a quantidade de bits menor
a resolução e consequentemente, maior a precisão do microcontrolador. Por isso,
em aplicações em que é necessário um altíssimo grau de precisão, normalmente
são utilizados conversores AD externos ao Arduino. Além do valor padrão de 5V
pode-se utilizar também uma referência externa de tensão aplicado ao pino AREF
do Arduino (SOUSA, 2013).
Como já vimos, o Arduino possui 6 canais para conversão analógica

digital, denotados pelos pinos de A0 a A5. Dessa forma, os pinos aos quais esses
canais estão associados devem ser utilizados sempre que um valor analógico deva
ser tratado. Para a configuração, leitura e escrita de valores analógicos utiliza-se
as funções apresentadas a seguir.
analogReference: A função analogReference(modo) é responsável por

selecionar a tensão de referência para a entrada analógica. No Arduino Uno
podem ser utilizados basicamente três modos: o DEFAULT que utiliza a referência
padrão 5V, o INTERNAL que utiliza a referência interna de 1,1V e o EXTERNAL
que utiliza uma tensão de referência aplicada ao pino AREF.
analogRead: Utilizada para a leitura de um valor analógico, a função

analogRead(pino) retorna o valor lido em uma escala que varia de 0 a 1023. Para
conversão em um valor analógico deve-se multiplicar o valor retornado pela
resolução calculada.
Para ver na prática os conceitos estudados aqui faremos a simulação de

um potenciômetro. O potenciômetro é basicamente uma resistência, cujo o valor
varia à medida que giramos o seu cursor móvel. A montagem do circuito no
Tinkercad é apresentada na Figura 14.
153
FIGURA 14 – MONTAGEM DO CIRCUITO NO TINKERCAD PARA SIMULAÇÃO DO

POTENCIÔMETRO
O que queremos é realizar a leitura do potenciômetro e visualizar esse

valor no monitor serial. Dessa forma, podemos definir o código simplesmente
como apresentado na Figura 15.
FIGURA 15 – CÓDIGO UTILIZADO PARA LEITURA DO POTENCIÔMETRO
Como o potenciômetro foi ligado entre a própria tensão de referência

(5V) e o GND o valor lido pelo pino A0 vai variar entre 0 e 1023 que é o valor
máximo e mínimo lido pela função analogRead. Dessa forma, ao girarmos o
cursor da esquerda para a direita temos o resultado apresentado pela Figura 16.
Para converter esse valor na tensão medida bastaria multiplicar pela resolução de
4,88mV, calculada anteriormente.
154
FIGURA 16 – LEITURAS OBTIDAS ATRAVÉS DA MEDIÇÃO COM O POTENCIÔMETRO
4 SAIDAS PWM
Como sabemos, os sistemas digitais trabalham com sinais binários: 0 ou 1,
ligado ou desligado, alto ou baixo. Contudo, frequentemente existe a necessidade
de se replicar valores analógicos utilizando esses sistemas. É nesse panorama que
a Modulação por Largura de Pulso (PWM) entre em cena. Segundo Souza (2014),
a técnica consiste em manter a frequência de uma onda quadrada fixa e variar o
tempo que o sinal fica em nível lógico alto.
A relação entre o tempo que a onda passa em nível alto e nível baixo é
conhecida como duty cicle, ou razão cíclica, em português. À medida que a razão
cíclica varia tem-se também uma variação do valor médio da onda. A Figura 17
apresenta a onda quadrada para diferentes valores de razão cíclica. Observe que
quanto maior esse valor, maior o valor médio da onda.
155
FIGURA 17 – ONDAS QUADRADAS COM DIFERENTES VALORES DE RAZÃO CÍCLICA
FONTE: Adaptado de <https://bit.ly/3rMQyCz>. Acesso em: 17 jun. 2021.
Dessa forma, para uma onda com razão cíclica de 0% tem-se uma onda
com nível baixo sempre, enquanto que para uma razão cíclica de 100% tem-se
nível lógico alto sempre. No entanto, entre esses valores, se obtém uma onda com
nível médio entre o valor máximo e mínimo. Para uma razão cíclica de 50%, por
exemplo, tem-se nível alto na metade do tempo e, portanto, um nível médio na
saída de 50% do valor máximo. De forma geral, o nível médio da onda de saída
pode ser calculado através da Equação 2.
(2)
As ondas com modulação PWM são geradas pelo Arduino através da

função analogWrite(pino, valor). É preciso, dessa forma, indicar um dos pinos que
tenham a função PWM e o valor da razão cíclica da onda. Esse valor é expresso
através do intervalo 0 a 255, onde 0 representa uma razão cíclica de 0% e 255 uma
razão cíclica de 100%.
Apesar do PWM ser utilizado em muitas outras aplicações, veremos nessa

seção um exemplo de controle de luminosidade de um LED. Basicamente, faremos
a alteração de luminosidade de um LED desde o valor mínimo (apagado) até um
valor máximo, e retornando novamente para o valor mínimo. Esse processo será
repetido a cada iteração da função loop(). A montagem do circuito no Tinkercad é
apresentada na Figura 18.
156
FIGURA 18 – CIRCUITO UTILIZADO PARA A VARIAÇÃO DE LUMINOSIDADE DO LED
O código utilizado para realizar o efeito que planejamos é apresentado

na Figura 19. Observe como os blocos FOR foram utilizados para incrementar e
decrementar gradualmente a razão cíclica.
FIGURA 19 – CÓDIGO UTILIZADO PARA VARIAÇÃO DA LUMINOSIDADE DO LED
Inicialmente, é declarada globalmente uma variável chamada brightess, que

receberá o valor da razão cíclica. A seguir, observe na função setup(), que mesmo
utilizando a função analogWrite é preciso definir o pino que será utilizado como
157
saída. Por fim, na função loop() são declarados dois blocos for, um para incremento
da variável brightness e outro para decremento. A cada iteração do bloco o valor
de luminosidade é passado como parâmetro para a função analogWrite, gerando o
efeito inicialmente de aumento da luminosidade e por fim de diminuição.
Uma forma prática de visualizarmos a forma de onda gerada pelo Arduino

é utilizar o osciloscópio presente no Tinkercad. Para isso basta posicionar os
terminais do osciloscópio junto aos terminais do LED e ajustar o tempo por
divisão para 30 ms. Realize esse procedimento e observe como a razão cíclica da
onda quadrada varia de acordo com o tempo.
5 TRANSMISSÃO SERIAL
Se tratando de microcontroladores é comum que um dispositivo tenha
que enviar ou receber informações de outro dispositivo. Um exemplo disso, é o
próprio monitor serial do Arduino. Sem perceber, estávamos nos comunicando
de forma serial com o computador ao qual o Arduino está conectado, recebendo
e enviando informações. Da mesma forma é possível comunicar o Arduino com
outros dispositivos, como módulos Bluetooth e até mesmo com outro Arduino.
Transmitir de forma serial um dado significa que esse dado é enviado de

forma sequencial bit após bit. Ao contrário, tem-se a comunicação paralela que
transmite cada bit simultaneamente através de vários fios. Apesar de parecer mais
rápida, a comunicação paralela necessita de sincronia entre os dados enviados,
o que acaba reduzindo a velocidade de transmissão (LAWRENCE, 2015). Dessa
forma, a comunicação serial é a mais utilizada atualmente para comunicação
entre dispositivos.
A comunicação serial utilizada pelo Arduino conta com dois pinos, um

para transmissão (TX) e outra para recepção de dados (RX). Dessa forma, ao
conectar dois dispositivos, o pino TX do primeiro deve ser conectar ao pino RX
do segundo, enquanto o pino RX do primeiro deve ser conectar ao pino TX do
segundo. Outro ponto importante é que os dois dispositivos devem manter o
mesmo GND, através da conexão em um ponto comum.
Para a comunicação entre o Arduino e computador podemos utilizar todas

as funções que já vimos anteriormente para o monitor serial. Como sabemos, é
possível inicializar a conexão a partir da função Serial.begin(velocidade), verificar
se existem dados disponíveis através da função Serial.Available(), realizar a leitura
desses dados com o Serial.read() e até mesmo enviar dados do Arduino para
outros dispositivos através das funções Serial.print(valor) e Serial.println(valor). No
entanto, para nos aprofundarmos mais nessa área veremos a seguir um exemplo
de comunicação entre dois Arduinos. Nessa situação, o processo é um pouco
diferente, pois teremos que programar dois Arduinos, apesar de utilizarmos as
mesmas funções que já conhecemos.
158
O funcionamento do circuito é bem simples: temos no Arduino 1 um botão,

que ao ser pressionado envia um comando para o Arduino 2. Esse comando,
ao ser recebido deve acionar um LED presente no Arduino 2. A montagem do
circuito para essa aplicação é apresentada na Figura 20.
FIGURA 20 – MONTAGEM DO CIRCUITO PARA COMUNICAÇÃO SERIAL ENTRE ARDUINOS
Naturalmente temos que desenvolver um código para o Arduino 1, que

ao receber o comando do botão, envia uma ordem para o acionamento do LED.
Para o Arduino 2, que ao receber o comando específico do Arduino 1, acione o
LED. Esse funcionamento é expresso em forma de código na Figura 21 e Figura 22,
enviados para o Arduino 1 e Arduino 2, respectivamente.
Como podemos observar, o Arduino 1 simplesmente aguarda que o botão

seja pressionado, e quando isso acontece, o estado do botão é transmitido ao
Arduino 2 através da função Serial.print(). Já o Arduino 2 permanece verificando,
através da função Serial.available(), se algum valor foi recebido via comunicação
serial, caso sim, esse caractere é lido e armazenado em uma variável. Caso o
caractere recebido seja igual a 1, estado gerado quando o botão é pressionado, o
LED é acesso. Em qualquer outra condição o LED permanece desligado.
Na prática, o LED permanece acesso enquanto estivermos pressionando

o botão, criando assim uma transmissão recorrente do estado do botão de um
Arduino para o outro. É importante notar que o Arduino só possui um módulo de
comunicação Serial, dessa forma, pode haver conflito caso o computador também
esteja transmitindo e recebendo dados.
159
FIGURA 21 – CÓDIGO ENVIADO PARA O ARDUINO 1
FIGURA 22 – CÓDIGO ENVIADOS PARA O ARDUINO 2
6 TIMERS
Os timers, ou contadores em português, são utilizados na maioria dos
processos internos do Arduino. Por detrás da função delay(), por exemplo,
existem contadores que determinam o tempo exato que a aplicação deve aguardar
antes de fazer qualquer outra coisa. Da mesma forma, existe um contador que
160
armazena o tempo que o código atual começou a ser executado. O valor desse
contador é retornado em milissegundos pela função millis(), sendo também um
ótimo exemplo de aplicação dos contadores no Arduino. Além da temporização,
os contadores são utilizados para a contagem de eventos externos, para a geração
de ondas PWM, para as interrupções, entre outras aplicações (SOUZA, 2015).
O atmega328 possui 3 módulos contadores, sendo o TIMER0 e TIMER2

de 8 bits e o TIMER1 o único de 16 bits. Por conta do Arduino, não existe a
necessidade de lidarmos diretamente com esses registradores. Em vez disso, basta
sabermos utilizar as principais funções que utilizam esses contadores. Funções
como analogWrite() e tone() utilizam os contadores, mas como já foram vistas nas
seções anteriores, não serão abordados novamente aqui. A seguir é apresentado o
funcionamento das demais funções que utilizam contadores no Arduino:
delay: algo que não focamos tanto sobre a função delay(tempo) até agora
é que existe uma pausa na execução do programa pelo tempo em milissegundos
determinado.
delayMicroseconds: similar a função delay(tempo) a delayMicroseconds(tempo)

também pausa a execução do programa pelo tempo determinado, contudo o valor
informado é considerado como sendo em microssegundos.
millis: basicamente, a função millis() retorna o tempo que se passou desde

o início da execução do programa em milissegundos.
micros: da mesma forma que a função millis() a função micros() também

retorna o tempo de execução do programa, mas em microssegundos.
Para aplicações mais simples, utilizar a função delay() talvez não seja
um problema, pois normalmente apenas um recurso é utilizado. Contudo, à
medida que o código vai crescendo em complexidade, se torna cada vez mais
arriscado parar a aplicação totalmente para uma contagem de tempo através da
função delay(). Imagine que um motor deva ser acionado a cada 30 segundos,
permanecendo mais 30 segundos ligado. Durante esse tempo digamos que seja
possível interromper essa operação apertando um botão. Com os períodos de
pausa gerados pela função delay(), simplesmente não teríamos como saber se o
botão foi pressionado. Uma solução nesse caso, envolve a utilização da função
millis() ou micros(), e é justamente isso que veremos como exemplo nesse tópico.
A nossa situação exemplo será simplesmente manter um LED piscando a

cada 5 segundos, até que um botão seja pressionado. A partir daí o LED seguirá
acesso continuamente. O circuito necessário, apesar de simples, é apresentado na
Figura 23.
161
FIGURA 23 – MONTAGEM DO CIRCUITO PARA EXEMPLO
Observe que não podemos utilizar a função delay() pois corre o risco de o
botão ser pressionado exatamente enquanto a função está sendo executada. Assim,
o código desenvolvido utilizando a função millis() como base é apresentado na
Figura 24.
FIGURA 24 – CÓDIGO DESENVOLVIDA PARA A SITUAÇÃO EXEMPLO
162
O entendimento do código é obtido através de três pontos chave: o

primeiro seria o uso da função millis() para piscar o LED, seguido do próprio
piscar do LED, e por último o estado do botão como forma de impedir que o LED
pisque e passe a ficar aceso de forma continua. Vamos entender cada um desses
pontos.
Inicialmente, observe que declaramos uma variável global chamada

anteriorMillis com valor inicial igual a zero. A cada iteração do loop(), a variável
atualMillis recebe o tempo atual desde o início da execução do código. Esse valor
é subtraído do valor de anteriorMillies e caso a diferença seja maior que o valor
do intervalo (5 segundos), o bloco dentro do IF é executado. Na prática, essa
condição só vai ser satisfeita a cada cinco segundos criando a condição perfeita
para o piscar do LED. A continuidade desse algoritmo depende da atribuição do
valor atual (atualMillis) para o valor anterior (anteriorMillies) na linha 19.
Como vimos, a condição para o acionamento do LED acontece a cada

cinco segundos dentro do bloco IF. Antes de realizar o acionamento, no entanto,
é verificado se o estado do botão é igual a zero, o que indica que o botão não
foi pressionado ainda e assim o LED deve continuar piscando. A mudança dos
valores do LED (HIGH ou LOW) é feito através do operador (!) que a cada iteração
muda o estado do LED para o seu valor complementar.
Com a condição dentro do bloco IF já se garante que caso o estado do

botão seja diferente de zero, o estado do LED não mude. No entanto, são os outros
dois últimos IFs, fora desse, que vão garantir que o estado do botão seja alterado,
quando o mesmo for pressionado. Fazendo com que o LED permaneça acionado
indefinidamente.
163
RESUMO DO TÓPICO 2
• Conversores AD permitem que o Arduino interprete valores analógicos como

temperatura, pressão e velocidade. O resultado de uma medição analógica é
um valor entre 0 e 1023 que para ser convertido para o valor real através da
multiplicação pela precisão do conversor.
• As saídas PWM geram valores analógicos através da alteração da relação

entre o tempo que a onda permanece em nível baixo e nível alto, conhecido
como razão cíclica.
• A transmissão serial é uma das tecnologias mais utilizadas para comunicação

entre dispositivos, sendo possível através dela a comunicação do Arduino
com o computador e com uma diversidade de outros dispositivos.
• Os contadores estão por trás de todas as funções de contagem de tempo no

Arduino, como a delay() e millis(). Foi visto que essa última apresenta uma
solução mais eficiente para atraso tempo que a função delay().
164
AUTOATIVIDADE
1 O Arduino possui seis canais com capacidade de conversão analógica digital

denotados de A0 a A5. Esse recurso é o responsável por interpretar a partir
de uma aproximação os valores analógicos recebidos pelo Arduino. Sobre
o conversor analógico-digital presente no Arduino, assinale a alternativa
INCORRETA:
a) ( ) Para medir um valor analógico o Arduino aproxima o valor medido a

através de degraus, que representam a resolução do dispositivo, ou o
menor valor que pode ser medido pela placa.
b) ( ) O Arduino apresenta uma resolução padrão de 4,88mV, não sendo
possível obter valores diferentes desse.
c) ( ) O valor medido é apresentado pelo Arduino em uma escala que vai de
0 a 1023, sendo necessário a multiplicação pela resolução para se obter
o valor real em volts.
d) ( ) Em uma resolução de 4,88mV, o valor 3,32V seria aproximado pelo
Arduino através de 680 degraus, sendo apresentado o valor de 3,318V
pelo dispositivo.
2 A modulação PWM é a forma como o Arduino consegue variar o tempo

em alto e baixo de uma onda quadrada de modo a obter um valor médio
variável entre um valor máximo e mínimo. De acordo com os fundamentos
da modulação PWM, classifique V para as sentenças verdadeiras e F para
as falsas:
( ) O valor médio de saída da onda gerada pela modulação PWM é

diretamente proporcional ao valor da razão cíclica, ou seja, à medida que
a razão cíclica aumenta, o valor médio aumenta também.
( ) A onda PWM é gerada pelo Arduino através da função analogWrite(),
através da relação 0 a 255, onde 0 representa uma onda com valor médio
igual a 0 e 255 uma onda com valor médio igual a 5V.
( ) O valor médio de saída da onda gerada pela modulação PWM é
inversamente proporcional ao valor da razão cíclica, ou seja, à medida
que a razão cíclica aumenta, o valor médio diminui.

a) ( ) V – F – F.
b) ( ) V – V – F.
c) ( ) F – V – V.
d) ( ) F – F – V.
165
3 Se comparado à transmissão paralela, a transmissão seria tem se mostrado
como melhor opção para comunicação entre dispositivos, sendo encontrada
não somente no Arduino mas em outras placas como ESP32 e Raspberry.
Com base transmissão paralela entre o Arduino e outros dispositivos,
analise as sentenças a seguir:
I- Cada Arduino possui um pino TX destinado para transmissão de dados

e um RX destinado para recepção de dados. Para realizar a comunicação
entre dispositivos esses pinos devem ser conectados igualmente, ou seja,
TX com TX e RX com RX.
II- Para que a comunicação funcione de forma adequada os terminais GND
de ambos os dispositivos devem ser conectados em um ponto comum.
III- No Arduino, as funções utilizadas para comunicação com o computador
não podem ser utilizadas para comunicação com outros dispositivos,
necessitando de uma biblioteca especifica para essa finalidade.

a) ( ) As sentenças I e III estão corretas.
b) ( ) Somente a sentença III está correta.
d) ( ) Somente a sentença II está correta.
4 As funções delay() e millis() fornecem resultados diferentes quando são

chamadas, mas podem ser utilizadas para o mesmo proposito que é
executar um determinado comando após um determinado período em
milissegundos. Explique em que situações a função millis() é mais indicada
que a função delay() e como uma pode substituir a outra.
5 Os pinos digitais do Arduino são tradicionalmente configurados em saída

(INPUT) e entrada (OUTPUT), contudo está disponível ainda um terceiro
modo que garante um funcionamento adicional ao pino configurado.
Pesquise a documentação da função pinMode() e explique como esse
terceiro modo funciona, apresentando também uma aplicação.
166
UNIDADE 3
TÓPICO 3 —
PROJETOS COM SENSORES E ATUADORES
1 INTRODUÇÃO
Os últimos anos têm trazido uma série de avanços na tecnologia, que,
por sua vez, impacta diretamente na forma como vivemos. Esses avanços estão
intimamente ligados à eletrônica e ao desenvolvimento de projetos embarcados.
O próprio conceito de Cidades Inteligentes, que está em evidência ultimamente,
é baseado no uso de circuitos microcontrolados para a aquisição e envio de
informações, buscando resolver problemas da sociedade. Entre as propostas
nessa área está a redução da violência, o monitoramento de crimes ambientais,
o melhor controle dos gastos públicos e a economia de recursos. Dessa forma, o
conteúdo que estudamos até agora, quando desenvolvido em forma de projetos,
tem aplicabilidade real em problemas da sociedade.
Por serem empregados em abordagens reais, os projetos profissionais não

têm margem para erro. Todo o funcionamento do circuito deve ser previsto de
forma detalhada, a simulação deve ser realizada de modo minucioso, a fim de
levar a menor quantidade de erro possível para o protótipo real, e os componentes
devem ser escolhidos sabiamente, visando sempre reduzir custos. Esse último
ponto é especialmente importante pois para produção em larga escala uma
diferença de centavos causa uma grande diferença econômica. Todo esse relato
pode causar um pouco de pressão em quem ainda está iniciando, contudo, nada
aparece de uma hora para outra. Os resultados que vão sendo obtidos nesses
projetos não acontecem rapidamente, e são normalmente o resultado do trabalho
de uma equipe de profissionais.
Visando aproximar a sua experiência com a de projetos mais avançados

na área, trazemos neste esse tópico uma visão ampla dos sensores e atuadores
que são utilizados atualmente, bem como o desenvolvimento de projetos que
resolvem problemas reais do dia a dia. A intenção é se aproximar o máximo
possível de uma abordagem profissional e também permitir a análise de projetos
mais desafiadores.
2 CONHECENDO OS SENSORES E ATUADORES

Em uma analogia com o corpo humano, os sensores seriam como os olhos
e ouvidos do Arduino enquanto os atuadores seriam como os braços e pernas.
Apesar de parecer um pouco exagerado, é isso mesmo que acontece. O sensor de
167
ultrassom, por exemplo, fornece ao Arduino a distância do sensor a um obstáculo,

o que é quase o mesmo que “enxergar” esse obstáculo. Já um motor CC, por
exemplo, é capaz de mover o Arduino de uma posição a outra, de acordo com os
comandos programados.
O intuito dessa seção é apresentar um apanhado dos principais sensores

e atuadores que estão em uso atualmente. Esse conhecimento facilitará a nossa
escolha nos projetos que seguirão. Vale lembrar que a lista a seguir, apesar de
apresentar componentes realmente comuns, está longe de ser exaurível.
2.1 SENSORES DE LUMINOSIDADE

Existem no mercado atualmente diversos sensores capazes de perceber
e medir luminosidade. O principal, e talvez o mais comum deles seria o Light
Dependent Resistor (LDR), ou Resistor Depende de Luz, em uma tradução
direta. Como o nome sugere, o LDR é uma resistência que varia de acordo com a
quantidade de luminosidade que incide na parte superior do mesmo (Figura 25).
Esse valor varia de quase zero em um ambiente muito iluminado até um valor
máximo em um ambiente de total escuridão. Além de possuir uma montagem
simples, o LDR é fácil de encontrar e possui o valor mais acessível em relação aos
outros sensores que veremos a seguir.
FIGURA 25 – VISTA SUPERIOR E LATERAL DE UM LDR
FONTE: <https://bit.ly/3j3q1x0>. Acesso em: 20 jun. 2021.
Com um LDR podemos verificar a variação da luminosidade, mas

quantificá-la em si não se torna tão preciso. Para aplicações onde a quantidade
de luz em si deve ser medida, pode-se utilizar o módulo BH1750. Conectado
ao Arduino esse módulo é capaz de fornecer o valor de luminosidade em lux,
em uma escala que vai de 1 a 65535 lux. O módulo se comunica com o Arduino
através de uma comunicação I2C, sendo possível ligar mais de um módulo em
um mesmo Arduino através de endereçamento dos dispositivos (CIA, 2016).
168
TÓPICO 3 — PROJETOS COM SENSORES E ATUADORES
A Figura 26 apresenta a vista superior desse módulo. Exceto os pinos VCC e

GND, utilizados para alimentação do módulo, os demais são utilizados para a
comunicação I2C citada anteriormente.
FIGURA 26 – VISTA SUPERIOR DO MODULO BH1750
FONTE: <https://bit.ly/37aTAqY>. Acesso em: 20 jun. 2021.
Para análise de raios ultravioleta é possível ainda a utilização dos módulos

UVM-30A ou GUVA-S12SD.
2.2 SENSORES DE TEMPERATURA

Outro mercado cheio de opções é o de sensores de temperatura. Um que
não pode faltar na lista é o DHT11. Esse módulo, além de medir temperatura é
capaz de medir também a umidade do ambiente. Internamente, a temperatura
é medida através de um termistor tipo NTP e a medição de umidade através de
um sensor modelo HR202. O circuito interno possibilita que esses sensores se
comuniquem facilmente com os Arduino através de uma biblioteca própria e de
uma comunicação serial. São suportadas medições em temperaturas no intervalo
de 0ºC a 50ºC, e valores entre 20% e 80% para umidade (AOSONG, 2021). A Figura
27 apresenta a vista do módulo.
FIGURA 27 – VISTA SUPERIOR DO MÓDULO DHT11
FONTE: <https://bit.ly/3lcWfIX>. Acesso em: 20 jun. 2021.
169
NOTA
O termistor é basicamente um semicondutor que varia sua resistência de

acordo com a variação de temperatura. São encontrados dois tipos desse componente:
o termistor tipo NTP, tem uma diminuição da resistência à medida que a temperatura
aumenta, enquanto que no tipo PTC, a resistência aumenta à medida que a temperatura
aumenta.
Uma opção um pouco mais barata que o DTH11, para que deseja medir
apenas temperatura, é o TMP36. O sensor é apresentado em um circuito integrado
com o mesmo encapsulamento de um transistor (Figura 28). Ao contrário do
DHT11, no entanto, o TMP36 apresenta a temperatura medida proporcionalmente
através de uma saída de tensão. Dessa forma, cada 10mV de tensão representa
1ºC, sendo essa conversão feita via código pelo programador. O sensor é capaz
de medir em um intervalo que vai de -40 ºC a 125 ºC, enquanto a precisão fica em
torno de ± 2 ºC (OLIVEIRA, 2020).
FIGURA 28 – SENSOR DE TEMPERATURA LM35
FONTE: <https://bit.ly/3rMWlbh>. Acesso em: 20 jun. 2021.
Para aplicações que necessitem de um pouco mais de precisão, o sensor

de temperatura MLX90614 é uma boa opção. Diferente dos demais a medição é
realizada por infravermelho, sem a necessidade que o sensor encoste o corpo a
ser medido. A precisão para esse sensor fica na faixa de ± 0,5 ºC dentro da faixa
de temperatura de -40 ºC a 125 ºC para ambientes e -70 ºC a 380 ºC para objetos
(MELEXIS, 2008). A Figura 29 apresenta o MLX90614 com a indicação dos pinos
de alimentação (VIN e GND) e comunicação I2C (SLC e SDA).
170
FIGURA 29 – SENSOR DE TEMPERATURA MLX90614
FONTE: <https://bit.ly/3ifyGNL>. Acesso em: 20 jun. 2021.
2.3 SENSORES DE DISTÂNCIA

Os sensores de distância, como já dissemos, são os olhos de robôs,
veículos autônomos, braços robóticos e outras aplicações contra obstáculos. São
encontradas, na maior parte das aplicações, duas tecnologias para detecção de
obstáculos. A primeira se baseia no cálculo da distância com base no tempo que
uma onda ultrassónica leva para sair, bater no obstáculo e ser refletida de volta
ao sensor. A segunda funciona da mesma forma, com a diferença de utilizar um
sinal infravermelho para detecção dos obstáculos.
Baseado no ultrassom, existe no mercado o sensor HC-SR04, que, além

de detectar obstáculos, é capaz de medir a distância até eles com uma precisão
de até 3mm. O HC-SR04 é capaz de realizar medidas em um intervalo que vai de
2cm a 4m, sendo uma boa opção para projetos de baixo custo e sem tanto rigor de
precisão. Outra opção com a mesma tecnologia é o XL-MaxSonar EZ0 linha MB.
Além de uma distância de medição de até 7,65m, esse sensor consome apenas
3,4mA, quase cinco vezes menos que o HC-SR04. A Figura 30 apresenta a vista do
sensor HC-SR04 onde é possível ver os pinos de alimentação (VCC e GND) e os
pinos de saída do pulso (ECHO) e entrada do pulso (TRIG).
Já o sensor de infravermelho é oferecido por vários fabricantes, sempre

com um emissor e um receptor. A Figura 31 apresenta um dos módulos mais
comuns. Basicamente, o dispositivo emite um sinal infravermelho de forma
continua. Ao aparecer um obstáculo, esse sinal é refletido pelo mesmo e recebido
pelo receptor. A saída do pino OUT vai então para nível baixo, indicando que um
obstáculo foi visto. O módulo possui uma capacidade de detecção que varia de
2cm a 80cm, sendo possível esse ajuste de distância via potenciômetro já instalado
na placa.
171
FIGURA 30 – SENSOR ULTRASSOM HC-SR04
FONTE: <https://bit.ly/3lrc1jB>. Acesso em: 20 jun. 2021.
FIGURA 31 – MÓDULO INFRAVERMELHO PARA DETECÇÃO DE OBSTÁCULOS
FONTE: <https://bit.ly/3C7YSSml>. Acesso em: 20 jun. 2021.
2.4 MOTOR CC
Continuaremos nossa exploração agora com os motores. Os motores
elétricos em geral são componentes que convertem energia elétrica em um campo
magnético capaz de gerar movimento. Motores de corrente continua (CC) são
bastante utilizados em eletrônica para dar movimento a aplicações, como veículos
autônomos e drones. Cada aplicação, no entanto, exige um tipo de motor CC com
características diferentes. Dessa forma, encontramos motores CC com tensão de
alimentação, rotações por minuto (RPM) e torque diferentes no mercado.
É importante destacar que a maioria dos motores CC possuem corrente

de alimentação acima dos 20mA que o Arduino Uno é capaz de fornecer nas
portas de E/S (ARDUINO, 2021). Desse modo, é comum o uso de drivers que são
responsáveis por fazer essa interface entre o microcontrolador e o motor em si.
Veremos a seguir exemplo de motores CC para sua utilização com o Arduino.
Os motores de 3V apresentados na Figura 32 são talvez os mais visto em

eletrônica de forma geral. Esses motores apresentam uma rotação de até 22000
RPM e uma corrente de até 120 mA.
172
FIGURA 32 – MOTOR CC 3V
FONTE: <https://bit.ly/3id7j6L>. Acesso em: 21 jun. 2021.
Para aplicações nas quais é necessário um pouco mais de torque os

motores CC normalmente são acoplados em caixas de redução. Esse equipamento
é composto por engrenagens que reduzem a velocidade do motor e aumenta o
torque em compensação. O motor GW370 (Figura 33) é um exemplo desse tipo.
Ele opera a uma tensão de 12V, possui um toque de 4,0 Kgf.cm e uma velocidade
de apenas 22 RPM em velocidade nominal.
FIGURA 33 – MOTOR DE ALTO TORQUE GW370
FONTE: FONTE: <https://bit.ly/3y9qZy1>. Acesso em: 21 jun. 2021.
Existem também motores como o da Figura 34 que são utilizados para

vibração. A placa com o motor possui uma tensão de alimentação entre 3,7V e
5,3V, e um pino IN que altera a intensidade de vibração de acordo com a variação
no nível de tensão.
173
FIGURA 34 – MÓDULO MOTOR DE VIBRAÇÃO
FONTE: <https://bit.ly/3x8dX2w>. Acesso em: 21 jun. 2021.
2.5 MOTOR DE PASSO

Os motores de passo são normalmente utilizados em aplicações que
necessitem de mais controle de movimento e precisão. Essa característica é
atingida através do movimento do motor em forma de passos. Na prática, várias
bobinas são organizadas de modo que o motor gire de uma bobina para outra em
um ângulo controlado. Dependendo da forma como foi construído, cada motor
de passo possui um ângulo específico que o motor percorre a cada acionamento
(STROSCHON, 2019). Quando menor esse ângulo maior é a precisão de
movimento desse motor. Diferente do motor CC, o motor de passo apresenta um
controle mais complexo pois as bobinas devem ser acionadas em ordem para o
movimento aconteça.
Bastante comum entre iniciantes, o motor de passo da Figura 35 é uma

boa opção para começar a desenvolver nessa área, principalmente por já vir
acompanhado do driver ULN2003 para acionamento. O motor possui uma
tensão de operação em 5V, que é também adequada para o desenvolvimento com
Arduino. A volta completa de motor é dada em 4096 passos, o que significa um
grau de aproximadamente 0,088º por passo.
FIGURA 35 – MOTOR DE PASSO COM DRIVER ULN2003
FONTE: <https://bit.ly/3BVCL1l>. Acesso em: 21 jun. 2021.
174
Outra opção já um pouco mais robusta, utilizada na maioria das

impressoras 3D e CNCs pelo torque elevado, são os motores de passo da NEMA.
O NEMA 17, apresentado na Figura 36, é um exemplo da categoria.
FIGURA 36 – MOTOR DE PASSO NEMA 17
FONTE: <https://bit.ly/3yafcPY>. Acesso em: 21 jun. 2021.
2.6 DISPLAY LCD

Apesar de não ser exatamente um sensor ou um atuador, o display de
LCD é utilizado em uma grande variedade de aplicações para apresentar dados
relevantes ao usuário. Hoje, com o desenvolvimento de novas tecnologias já
existem no mercado opções de telas de vários, com opção de touch screen, e até
mesmo com tecnologia de e-paper.
A escolha obviamente, depende da aplicação, da quantidade de informação

que será exibida na tela e do grau de sofisticação que deseja se empregado. Para
projetos mais simples é corriqueiramente utilizado o display LCD 16x2. Isso
significa que esse display apresenta 2 linhas com 16 caracteres cada. O display
LCD 16x2 apresentado na Figura 37, apresenta uma interface de comunicação
I2C, a partir do controlador JHD1804. Na pratica, esse tipo de comunicação reduz
a quantidade de pinos que são requeridos pelo Arduino. São necessários apenas
os pinos de alimentação e dois pinos para comunicação.
FIGURA 37 – DISPLAY LCD 16X2 COM COMUNICAÇÃO I2C
FONTE: <https://bit.ly/3jl6Lvd>. Acesso em: 21 jun. 2021.
175
3 PROJETO DE UM POSTE ELETRÔNICO

Há um bom tempo que os postes utilizados nas vias públicas são munidos
de dispositivos para o acionamento automático das lâmpadas. Esse circuito,
além de economizar energia, dispensa o uso de um profissional para realizar o
acionamento manual, sendo assim bastante eficiente para prefeitura. Nessa seção
replicaremos o funcionamento de um poste, desenvolvendo nossa própria versão
eletrônica com o Arduino. A intenção é replicar o projeto no Tinkercad através de
uma abordagem realística do problema.
Vamos iniciar com a descrição do projeto. O que queremos é criar um

circuito que seja capaz de ligar um LED a partir do momento que a iluminação
do ambiente comece a diminuir, e desliga-lo quando a iluminação do ambiente
voltar a aumentar. A fim de economizar energia, o LED deve ser acesso de modo
gradual, garantindo iluminação total apenas quando estiver totalmente escuro.
A primeira coisa que precisamos pensar para desenvolver esse projeto

é como podemos perceber essa luminosidade. Como vimos na seção anterior,
existem várias opções de sensores para esse proposito no mercado. Considerando
que não precisamos de uma medição precisa da luminosidade, o LDR é nossa
melhor opção nesse caso. É um sensor barato e simples de utilizar com o Arduino.
Além dele e do Arduino em si, utilizaremos um LED com resistor de 330 ohm
para limitação da corrente.
Partindo para a montagem do circuito, devemos conectar o LDR a uma

porta analógica do Arduino e o LED a um pino com saída PWM, uma vez que
precisaremos variar a luminosidade do LED à medida que o luz ambiente for
diminuindo. É necessário ainda um resistor de 10k entre o LDR e o terminal GND
a fim de facilitar a precisão das medições. Dessa forma, a montagem do circuito
completo é apresentada na Figura 38.
FIGURA 38 – MONTAGEM DO CIRCUITO NO TINKERCAD PARA O PROJETO POSTE

ELETRÔNICO
176
Por sua vez, o código desenvolvido para essa aplicação é apresentado na

Figura 39. A lógica por trás do código é na verdade bem simples. A cada iteração
da função loop() é realizada a medição do valor medido pelo LDR. A partir daí são
estabelecidos valores a partir do qual o LED começará será acesso com diferentes
valores de luminosidade. Para valores lidos abaixo de 800 o LED é acesso com
aproximadamente 25% da luminosidade máxima, até atingir um limite de 500 em
que o LED é acesso em sua totalidade. Acima de 800 o LED permanece apagado,
aguardando que a iluminação do ambiente diminua.
FIGURA 39 – CÓDIGO DESENVOLVIDO PARA O PROJETO POSTE ELETRÔNICO
Como vimos, a partir do momento que a iluminação natural diminui as

luminárias dos postes permanecem ligadas até que a luz do Sol retorne, quando
são apagadas automaticamente. Contudo, nem sempre existe alguém passando
nas redondezas, de modo que essas luzes poderiam ser acessar durante a noite
apenas quando alguém estivesse passando por perto. Que tal incrementar
o projeto que apresentamos e incluir um sensor de presença para atingir esse
funcionamento?
177
4 PROJETO DE UM ALARME DE PRESENÇA

Os microcontroladores têm uma grande aplicação na área de segurança.
São alarmes, dispositivos para acesso de pessoas, câmeras inteligentes, entre
várias outras aplicações. Devido à natureza da aplicação esses equipamentos
são projetados para serem confiáveis, apresentando a menor quantidade de
defeitos possível. De modo a contribuir com o seu conhecimento nessa área,
apresentaremos nessa seção um sensor de presença com alarme. O funcionamento
esperado é bem simples. Queremos que sempre que for detectado a presença
de uma pessoa no ambiente um alarme seja acionado de forma a coibir a ação
ilícita. O circuito deve ainda possuir uma forma de desativar o alarme, em caso
de acionamento acidental.
Para o desenvolvimento desse projeto precisaremos, obviamente, de

um sensor de presença. A melhor opção para essa aplicação seria um sensor
PIR, principalmente pelo seu preço acessível e pela sua detecção em um raio
de 7 metros. O sensor de ultrassom, nesse caso, não seria a melhor opção pelo
alcance reduzido e por não precisarmos exatamente medir distância. O sensor
PIR funciona basicamente através de dois pinos de alimentação e um pino de
dado. Ao ser detectado movimento este pino vai para nível alto, por um período
determinado de tempo. Caso não seja detectado movimento o pino de dado volta
para o nível baixo, até que seja detectado movimento novamente.
Além do sensor de presença, vamos precisar de um sonorizador, que

funcionará como alarme e um botão para resetar o dispositivo. O arranjo desses
componentes no Tinkercad é apresentado na Figura 40.
FIGURA 40 – MONTAGEM DO PROJETO ALARME DE PRESENÇA
178
Agora, o que o código precisa fazer é ficar aguardando uma resposta do

sensor de presença, e caso seja detectado algum movimento acionar o sonorizador.
A partir daí o código precisa aguardar pelo acionamento do botão para desativar
o alarme. O código que realizar esse funcionamento é apresentado na Figura 41.
FIGURA 41 – CÓDIGO PARA O PROJETO DE ALARME DE PRESENÇA
Para atingir o funcionamento esperado foi declarado uma variável

chamada estado, assim a cada iteração do loop() a leitura do sensor é feita e caso
seja recebido um valor alto, o estado do alarme é setado em 1. A partir daí, a cada
iteração, um breve tom de 10 ms é emitido no sonorizador através da função
tone(). Esse tom só para de ser emitido quando o botão é pressionado, alterando o
valor da variável estado para 0.
Apesar de simples, o código da Figura 41 apresenta uma forma interessante

de criar estados em que um determinado dispositivo é acionado enquanto uma
determinada condição acontece.
5 PROJETO DE UM TERMÔMETRO DIGITAL

Os termômetros são equipamentos comuns que vemos no dia a dia capazes
de medir a temperatura de um corpo através do contato. Em sua versão digital,
é possível ver o valor da temperatura em um display, sendo bem mais simples
179
interpretar o resultado obtido. Nesse projeto iremos criar nossa própria versão
de um termômetro digital, mas com umas melhorias. Serão incluídos dois LEDs,
um vermelho e outro azul, que indicarão febre ou hipotermia, respectivamente,
a partir do valor medido. Para exibir o resultado da medição um display LCD
16x2 será utilizado. Dito isso, podemos chegar a uma descrição do circuito. Ele
deve receber o valor de um sensor de temperatura, exibir esse valor no display
e caso este seja menor ou igual que 35 ºC, deve acionar o LED azul, indicando
hipotermia. Em contrapartida, ao registrar uma temperatura maior ou igual a
38ºC, o LED vermelho deve ser acesso, indicando febre.
Para medição de temperatura poderíamos simplesmente utilizar o LM35,

que vimos anteriormente, por ser um sensor relativamente simples de trabalhar,
que cumpre o que a aplicação pede e possui baixo custo, contudo o mesmo não
está disponível no Tinkercad. No lugar dele é disponibilizado o TMP36 que
possui características semelhantes ao LM35, como a precisão e saída de tensão
proporcional a temperatura medida. Assim como o LM35, o sensor possui o
mesmo encapsulamento de um transistor. Dos três pinos disponíveis, dois são
destinados para a alimentação e o outro para a saída de tensão.
Além do sensor de temperatura, vamos precisar basicamente do display e

mais dois LEDs, um azul e outro vermelho com resistores de 220Ω. A montagem
do circuito é apresentada na Figura 42.
FIGURA 42 – CIRCUITO PARA O PROJETO TERMÔMETRO DIGITAL
Observe que nessa montagem utilizamos uma miniprotoboard

para organização dos fios. Apesar disso a conexão dos componentes não é
complicada: os LEDs são conectados a portas digitais do Arduino, enquanto
o sensor de temperatura na porta analógica A0. A montagem do display LCD
segue basicamente a montagem apresentada por Thomsen (2011), contudo sem a
utilização do potenciômetro para o controle de luminosidade do display.
180
O código desenvolvido para o projeto é apresentado na Figura 43.
FIGURA 43 – CÓDIGO DESENVOLVIDO PARA O PROJETO TERMÔMETRO DIGITAL
Para o controle do display a função LiquidCrystal.h foi utilizada, sendo

criada uma nova instância já na segunda linha com os pinos ao qual o display
estava conectado. Similar ao monitor serial, a função LCD.begin(16,2) inicializou
o display, informando as colunas e as linhas disponíveis. Logo em seguida a
palavra “Temperatura” foi impressa na tela a partir da coluna zero e da linha zero
do display. Isso foi possível, pois a posição padrão do display fica justamente
nessa posição. Já na função loop() o código inicia com a leitura analógica do pino
ao qual o sensor de temperatura está conectado. Como sabemos o retorno da
função analogRead(pino) é um valor que varia de 0 a 1024. Para convertemos esse
valor em tensão precisamos multiplicar o valor lido pela precisão, que no caso
do Arduino é 4,88mV, ou 0,00488V como apresentado no código. Obtido o valor
181
em tensão temos que converter esse valor em temperatura. Para realizar essa
conversão temos que saber que a 10mV temos 1 ºC. Dessa forma o valor de tensão
obtido deve ser dividido por 10mV para obter o valor em temperatura. Contudo,
para o TMP36 a tensão é dada com um deslocamento de 0,5V, de forma que esse
valor deve ser subtraído antes de se dividir pela escala.
Ao ser obtido o valor de temperatura em graus célsius o cursor do display

é movido para a segunda linha da primeira coluna e o valor medido é impresso a
partir daí. A partir do valor de temperatura o código verifica se uma das condições
de febre ou hipotermia é satisfeito e acende o respectivo LED para cada situação,
caso não, os dois permanecem desligados.
Entendido o funcionamento, inicie a simulação e verifique se tudo está

funcionando como deveria. Uma boa opção para incrementar esse projeto
é desenvolver um alarme que indique quando o usuário pode remover o
termômetro, ou mesmo a inclusão de um terceiro LED que indique quando a
temperatura o usuário está dentro da esperada para uma pessoa saudável.
182
MONTAGENS ELETRÔNICAS – COMO FAZER E O QUE MONTAR
Newton C. Braga
O domínio da capacidade de realizar montagens eletrônicas é algo

extremamente atraente. Você já pensou na possibilidade de montar seus próprios
aparelhos eletrônicos, coisas que não podem ser compradas prontas ou mesmo
criadas por você mesmo? Se você frequenta este site, lê nossos artigos em
revistas ou nossos livros, certamente é porque se sente atraído por este tipo de
atividade, e até mesmo já tentou dar os primeiros passos neste sentido. Se você
é um montador avançado, certamente já domina muitas técnicas, mas mesmo
assim será interessante dar uma olhadinha neste artigo para ver se você está no
caminho certo e talvez encontrar explicações sobre o porquê de determinados
projetos não terem “dado certo”.
A imagem do pequeno cientista ou de senhor aposentado que no sótão

ou garagem de sua casa cria coisas mirabolantes, como as vistas nos filmes da
Disney, em “de Volta para o Futuro” ou ainda, “Querida, Encolhi as Crianças”,
e mesmo outros, não está muito longe da realidade. É claro que existem limites
(seguros) para o que se pode montar utilizando a tecnologia acessível que temos
hoje. Mesmo com essa tecnologia cujas peças podem ser obtidas de equipamentos
velhos, fora de uso, ou compradas pela internet ou através de um fornecedor
local, o leitor não imagina quantas coisas interessantes podem ser feitas. O
amador pode criar seus próprios circuitos eletrônicos e se divertir, ao mesmo que
aprende. O estudante pode criar os mais diversos equipamentos para seu próprio
uso aperfeiçoando seus conhecimentos das matérias lecionadas na escola. O
professor pode montar aparelhos para enriquecer suas aulas e até mesmo repassar
os projetos para seus alunos, aplicando-os nos estudos de ciências. O profissional
pode criar seus protótipos que no futuro podem resultar em produtos comerciais
lucrativos.
Por que não começar uma indústria no próprio quintal de sua casa,
com um produto criado por você mesmo? Lembramos que Bill Gates começou
seu rendoso negócio lendo uma revista de eletrônica (Popular Electronics) nos
Estados Unidos, de onde tirou a ideia de montar seu primeiro computador e
depois criar o sistema operacional que se tornou o produto que o enriqueceu
(DOS). Para fazer tudo isso não basta ter um local apropriado e boa disposição. É
preciso saber como montar e o que se pode montar.
É justamente visando esses dois itens que preparamos esse artigo, o

primeiro de uma série, baseado em mais de 50 anos de experiência em montagens,
projeto e publicação de artigos, muitos dos quais resultaram em produtos de
183
sucesso, foram aplicados em escolas e deleitaram muitos leitores durante todo

esse tempo. Sim, 50 anos, pois comecei cedo e já aos 13 anos de idade montava
meus circuitos e publicava artigos em revistas!
MONTANDO CIRCUITOS ELETRÔNICOS
Montar circuitos eletrônicos é um tipo de trabalho que pode ter as

mais diversas finalidades. Diferentemente do que muitos possam pensar não é
apenas o técnico de uma empresa que deseja desenvolver o projeto de um novo
produto que se envolve nesse tipo de atividade. Montar circuitos eletrônicos é
uma atividade altamente instrutiva, interessante e pode até ser extremamente
lucrativa, dependendo do que o leitor desenvolva. Muitas grandes empresas de
hoje começaram com seus proprietários montando equipamentos eletrônicos de
forma artesanal em suas garagens (falamos de Bill Gates nos Estados Unidos, mas
existem muitos exemplos em nosso próprio país como o Sr. Geraldo Lewinsky da
Metaltex que começou com sua famosa indústria fabricando relés numa garagem
de sua casa).
Mas por que montar aparelhos eletrônicos? A comodidade de se comprar

a maioria dos equipamentos eletrônicos prontos, e a custos muito baixos em
alguns casos, pode levar o leitor a pensar que ninguém precisa montar aparelhos
eletrônicos ou que ninguém se preocupa com isso. Não é verdade.
A maioria dos equipamentos de uso comum como rádios, gravadores,

telefones, transceptores, games, aparelhos de som podem ser comprada pronta
a preços que até são menores do que nos custaria montá-los se comprássemos
peça por peça. Isso ainda tem o agravante de que caixas e muitos componentes
desses aparelhos não são vendidas separadamente causando sérios problemas
a um eventual montador. A parte mecânica das montagens eletrônica é um dos
principais obstáculos à montagem de muitos equipamentos. É claro que, quando
falamos em montagens, não nos referimos a estes aparelhos e nem mesmo à
finalidade básica que eles possuem: atender ao grande consumidor numa função
comum. Aparelhos de uso comum que podem ser comprados prontos não são o
que realmente nos interessa montar. Não montamos aparelhos de som, telefones
celulares, monitores de computadores ou televisores.
Montamos aparelhos eletrônicos diferenciados, aparelhos que não podem

ser encontrados no comércio, pois atendem a uma finalidade específica que só
nós desejamos ou precisamos como:
a) Aprender, descobrir coisas novas
Não há dúvida alguma que a principal finalidade que temos hoje na

realização de montagens eletrônicas é aprender tecnologia. E, quando falamos
em tecnologia ela tanto pode ser para se trabalhar com ela naquele momento
como para aprender o necessário para passar para um degrau mais avançado
num curso técnico ou superior. O interessante das montagens eletrônicas é que
184
elas podem ser feitas em diversos níveis. Podemos ter montagens simples com
poucos componentes que o iniciante, ou mesmo estudante das escolas de nível
fundamental e médio podem completar com facilidade. Podemos ter montagens
intermediárias adotadas no curso técnico e elaboradas por professores para
ilustrar suas aulas. Podemos finalmente ter montagens complexas utilizadas pelos
desenvolvedores e profissionais que até podem criar algo novo e comercializar
com vantagens. Este é o motivo que na seção de “Artigos” neste site, fizemos uma
divisão de categorias, para que cada um possa ir exatamente aonde está o que
deseja.
Evidentemente, o leitor deve ter a consciência de que, sem preparo e

experiência não deve tentar, de imediato, montagens complicadas quando não
consegue ainda fazer as mais simples. Veja que no nosso site falaremos muito
dos professores do ensino fundamental, médio e técnico assim como de seus
alunos. Esse é um público que pode se beneficiar de uma forma muito ampla
da capacidade de realizar montagens eletrônicas. Veja no nosso site a página de
Educação Tecnológica.
b) Fazer coisas que não existem prontas como aparelhos comerciais
A maioria dos aparelhos que podemos montar são coisas que normalmente
não podem ser encontradas prontas nas casas especializadas, já falamos disso.
Por isso, a grande vantagem de saber montar coisas eletrônicas é que podemos
ter um produto exclusivo. Dificilmente posso encontrar pronto um circuito que
acione uma campainha quando meu rádio relógio despertar, mas posso montar
um. Dificilmente posso encontrar pronto um controle para um motor de um
brinquedo que pretendo adaptar, mas posso montar um. Não encontrarei pronto
um sistema que controle a maquete que estou desenvolvendo, mas posso montar
um. Não encontro nas lojas um espião eletrônico que possa interceptar conversas
à distância, mas posso montar um.
E, com sorte temos a possibilidade de montar projetos para realmente

ganhar dinheiro. Percorrendo as lojas e pontos de vendas em São Paulo, por
exemplo, vimos à venda diversos projetos que publicamos em revistas e que
foram adaptados para se tornarem produtos comerciais! Alguns exemplos:
Circuito que acende a luz quando escurece.

Alarme para pendurar na maçaneta da porta.
Alarme que toca quando crianças choram.
Controle remoto através da rede de energia.
c) Ter a satisfação pessoal de dominar a ciência mais importante de nosso tempo
Dominar a eletrônica não significa apenas uma satisfação pessoal, mas

também uma integração melhor com o mundo moderno. Essa integração pode
levar a uma maior segurança pessoal, maior facilidade em usufruir o que há
de mais moderno em nosso tempo, pelo entendimento de seu princípio de
185
funcionamento, e também maior capacidade de escolher o produto certo para

seu uso. Uma pesquisa recente mostrou que uma boa parte dos acidentes que
ocorrem envolvendo equipamentos eletrônicos poderia ser evitada se as pessoas
envolvidas conhecessem um pouco de seu princípio de funcionamento. Quem já
não ouviu falar de pessoas que se acidentam pela utilização indevida de certos
aparelhos casos como:
Usar eletrônicos ligados à rede de energia quando na banheira.

Ligar equipamentos em tomadas que não suportam sua potência.
Não observar o aterramento em aparelhos potencialmente perigosos.
Superdimensionar a potência de um aparelho para uma aplicação.
Usar um equipamento para uma finalidade para a qual ele não foi
projetado.
Tentar modificar um equipamento sem ter conhecimento técnico para
isso.
Fazendo montagens eletrônicas conhecemos melhor princípios de

operação de circuitos que estão presentes em todos os equipamentos eletrônicos
modernos. Podemos interpretar melhor manuais de uso e instalação, aproveitar
melhor todas as funções de um equipamento, ter mais segurança no seu uso.
Quantos dos leitores sabem utilizar corretamente todas as funções do controle
remoto de seu televisor, DVD ou videocassete? Quantos leitores conseguem
fazer todas as interligações dos periféricos a um computador ou de um televisor
ao videocassete, DVD e equipamento de som sem se atrapalhar ao consultar o
manual? Enfim, montar significa conhecer e conhecer significa usar ou comprar
melhor.
Quem pode montar? As montagens eletrônicas estão ao alcance de todos.

Não é preciso ser um “expert” com um curso superior ou técnico de eletrônica para
poder montar em casa aparelhos eletrônicos. Pessoas comuns, que não tenham
uma preparação prévia, ou que estejam no processo de adquirir essa preparação,
profissionais que ainda não se atreveram a fazer montagens e profissionais de
outras áreas que desejam aplicar a eletrônica prática em sua atividade são alguns
exemplos. Analisemos melhor os casos possíveis de pessoas que podem fazer
montagens e para as quais este livro será útil (veja os demais na versão completa):
a) Professores e alunos de cursos técnicos e de engenharia
Não existe ensino técnico sem a prática. No entanto, não basta os

conhecimentos adquiridos nas aulas práticas para se formar o verdadeiro
profissional. É preciso mais. É preciso montar circuitos, mesmo que simples,
como uma preparação para o manuseio de componentes, instrumentos e
ferramentas que são exigidos na manutenção de equipamentos mais complexos.
Trabalhando com tecnologia intermediária o aluno se prepara para entender e
manusear melhor os equipamentos que usam qualquer tecnologia, inclusive a
mais avançada. Este trabalho é absolutamente necessário como degrau para a
aquisição das habilidades exigidas para o trabalho com componentes de todos
186
os níveis de tecnologia. A montagem bem planejada de circuitos que utilizem os

princípios estudados nos cursos técnicos é algo que não pode faltar.
b) Profissionais de desenvolvimento
Os profissionais do desenvolvimento de circuitos eletrônicos não estão

apenas nas indústrias. Muitas pessoas têm encontrado fontes de renda bastante
compensadoras montando e vendendo certos tipos de circuitos eletrônicos que
não são fabricados pelas empresas de maior porte, fazendo sua instalação ou
mesmo reparação. Veja que, mesmo aqueles que não pretendem montar aparelhos
eletrônicos para vender precisam saber como isso é feito. Os profissionais que
fazem vendas técnicas, instalação e manutenção de equipamentos eletrônicos
precisam conhecer os princípios de funcionamento de seus produtos e para isso
nada melhor do que saber como montar coisas semelhantes.
O que podemos montar? Não existe um limite para o que um montador

habilidoso e que tenha recursos apropriados pode montar. As montagens
eletrônicas podem ser classificadas em níveis de dificuldades que exigem
diferentes graus de conhecimento e habilidade dos montadores e também
equipamentos e ferramentas adicionais. Assim, podemos fazer a seguinte
separação das montagens em várias categorias:
a) Montagens Simples Para Estudantes e Iniciantes
Estudantes, professores do ensino fundamental e médio podem montar

circuitos eletrônicos relativamente simples tanto para complementar o ensino
tradicional com o uso de tecnologia como para ilustrar aulas ou para fazer parte
dos programas de matérias eletivas. Normalmente são montagens feitas em
matrizes de contactos, ponte de terminais ou placas de circuito impressos com
componentes simples, normalmente poucos transistores e no máximo um ou dois
circuitos integrados. Podemos dizer que estudantes e amadores a partir dos 9
anos de idade já podem realizar muitas das montagens incluídas nessa categoria.
Podemos incluir os seguintes projetos nesse grupo:
Controles de motores.
Circuitos simples de corrente contínua.
Pequenos transmissores.
Excitadores de LEDs.
Osciladores de Áudio.
Rádios experimentais.
b) Projetos Intermediários
Esses já são projetos que preferivelmente devem ser realizados em

matrizes de contacto, placas universais ou placas de circuito impresso contendo
componentes como circuitos integrados. Professores, estudantes e amadores
podem elaborar projetos de razoável complexidade tanto para usar nos seus
187
cursos como para próprio uso. Como elaborar as placas de circuito impresso para
essas montagens é algo que ensinaremos neste livro. Nesta categoria podemos
enquadrar os seguintes projetos:
Controles PWM de motores.

Controles remotos com PLL.
Transmissores de rádio e TV.
c) Projetos avançados
Esses já são indicados para os montadores experientes que conseguem

fazer placas de circuito impresso precisas com grande quantidade de componentes
ou trilhas bastante estreitas. São projetos que se baseiam tanto numa quantidade
elevada de componentes (discretos e circuitos integrados) como também em
microprocessadores. Para esses casos, o montador também deve ter recursos de
programação, se forem utilizados microprocessadores, e deve ter experiência
de como fazer isso. Podemos dar como exemplo dessa categoria os seguintes
projetos:
Projetos com microprocessadores.

Interfaces de controle.
Automatismos complexos.
Circuitos de controle de robôs.
FONTE: <https://www.newtoncbraga.com.br/index.php/projetos-educacionais/405-montagens-
-eletronicas-como-fazer-e-o-que-montar-art018.html>. Acesso em: 22 jul. 2021.
188
RESUMO DO TÓPICO 3
• Os sensores são responsáveis pela percepção do mundo externo através de

medições como temperatura, luminosidade e distância.
• Os motores são a forma de dar movimento para aplicações como drones,

braços robóticos e veículos autônomos.
• Os motores de passo são utilizados em aplicações que necessitem de uma

precisão do movimento maior, enquanto os motores CC são necessários para
aplicações que necessitem de mais velocidade, ou maior toque, através do uso
das caixas de redução.
• É possível desenvolver projetos com aplicação real a partir de componentes

simples e um Arduino. Foram utilizados nesses projetos sensores de
luminosidade, temperatura e presença, assim como sonorizadores, botões,
LEDs e outros componentes para integração.
CHAMADA

189
AUTOATIVIDADE
1 É através dos sensores que o Arduino consegue perceber os estímulos

presentes no meio externo, como temperatura, luminosidade e a presença
de obstáculos. Sobre os sensores que realizam a medição dessas variáveis,
a) ( ) O módulo BH17 é capaz de fornecer a medição precisa da luminosidade

em uma escala que varia de 0 a 65535 lux.
b) ( ) O LM35 é um exemplo de sensor de temperatura capaz de realizar
medições em um intervalo que vai de -40ºC a 125ºC. A tecnologia
utilizada nesse sensor permite a medição de temperatura a distância,
sem a necessidade de o sensor encostar no corpo a ser medido.
c) ( ) Sensores como o HC-SR04 realizam a medição de distância através
de ondas ultrassónicas que batem no obstáculo e retornam ao sensor.
O processo é similar ao sonar utilizado por morcegos para localizar
obstáculos.
d) ( ) O DHT11 é um módulo capaz de medir temperatura e umidade,
graças a um termistor tipo NTP e um sensor modelo HR202 presente
no dispositivo.
2 O conhecimento a respeito dos principais sensores disponíveis no mercado

é útil para a escolha de componentes ajustados à aplicação que está
sendo desenvolvida. Sobre os recursos presentes nos principais sensores
disponíveis no mercado, associe os itens utilizando o código a seguir:
I- LDR
II- Módulo Infravermelho
III- Sensor MLX90614
IV- LM35
( ) Ao aparecer um obstáculo, o sinal emitido é refletido, sendo recebido pelo

receptor. Dessa forma, o sensor consegue detectar obstáculos em uma
distância que varia de 2cm a 80cm.
( ) Utiliza de sinais infravermelho para realizar a medição de temperatura
a distância, ou seja, sem a necessidade do sensor encosto o corpo a ser
medido.
( ) A percepção da quantidade de iluminação está associada à variação da
resistência do sensor, de modo que quanto maior a resistência menos
iluminação existe no ambiente.
( ) As medições são obtidas através de um sinal de tensão, sendo convertido
para temperatura em um fator de 1 ºC para cada 10mV medido.
190
a) ( ) II – I – III – IV.
b) ( ) III – I – II – IV.
c) ( ) I – III – I – IV.
d) ( ) II – I – IV – III.
3 Os motores são utilizados para dar movimento a diversas aplicações

eletrônicas, contudo, a diferença entre os motores CC e o motor de passo
deve ser observado de modo a escolher a melhor opção para cada aplicação.
Com base nas diferenças entre o motor CC e o motor de passo, analise as
sentenças a seguir:
I- Os motores CC possuem um conjunto de bobinas posicionadas de

forma que o motor gire de uma bobina para outra rapidamente. Essa
característica faz com que os motores CC alcancem altas velocidades.
II- O motor de passo é normalmente empregado em aplicações que necessitem
de precisão no movimento. Dessa forma, cada motor se movimenta em
um ângulo fixo, de forma que quanto menor o ângulo maior a precisão do
motor de passo.
III- É possível aumentar o torque de um motor CC através do uso de caixas de
redução. Esse equipamento nada mais é do um conjunto de engrenagens
que são acopladas ao eixo do motor, diminuindo a velocidade e
aumentando o torque.

b) ( ) Somente a sentença I está correta.
4 Durante o projeto do poste eletrônico foi proposta a implementação de

um sensor de presença para que mesmo durante a noite a lâmpada só
fosse acesa caso houvesse detecção de movimento. Incremente o código
apresentado na Figura 39 para executar essa funcionalidade. Considere o
sensor PIR instalado na porta 2 do Arduino.
5 O projeto do termômetro digital apresenta um LED vermelho, indicador

de febre, e um LED azul, indicador de hipotermia, contudo, não fica
bem explicito quando a temperatura está na faixa aceitável. Dessa forma,
acrescente um LED verde ao projeto e incremente o código da Figura 43
para que sempre que a temperatura estiver aceitável (entre 35 ºC e 38 ºC) o
LED verde seja acesso.
191
REFERÊNCIAS
AOSONG. Temperature and humidity module: dht11 product manual. DHT11
Product Manual. 2021. Disponível em: https://img.filipeflop.com/files/downlo-
ad/Datasheet_DHT11.pdf. Acesso em: 20 jun. 2021.
ARDUINO. ARDUINO UNO REV3. 2021. Disponível em: https://store.arduino.

cc/usa/arduino-uno-rev3. Acesso em: 21 jun. 2021.
CIA, A. e. Sensor de Luminosidade BH1750 com Arduino. 2016. Disponível em:

https://www.arduinoecia.com.br/BH1750-sensor-de-luminosidade-lux. Acesso
em: 20 jun. 2021.
LAWRENCE, D. Comunicação Serial x Comunicação Paralela-Entenda Tudo.

2015. Disponível em: https://bit.ly/3rL4tsJ. Acesso em: 17 jun. 2021.
MATTEDE, H. O que é osciloscópio e para que serve? 2021. Disponível em:

https://www.mundodaeletrica.com.br/o-que-e-osciloscopio-e-para-que-serve/.
Acesso em: 3 jun. 2021.
MELEXIS. MLX90614 family. 2008. Disponível em: https://img.filipeflop.com/

files/download/Datasheet_MLX90614.pdf. Acesso em: 20 jun. 2021.
OLIVEIRA, E. Como usar com Arduino: sensor de temperatura tmp36. Sensor

de Temperatura TMP36. 2020. Disponível em: https://bit.ly/3fcXrrT. Acesso em:
20 jun. 2021.
SOUSA, F. Timers do ATmega328 no Arduino. 2015. Disponível em: https://

www.embarcados.com.br/timers-do-atmega328-no-arduino/. Acesso em: 18 jun.
2021.
SOUSA, F. Usando as saídas PWM do Arduino. 2014. Disponível em: https://

www.embarcados.com.br/pwm-do-arduino/. Acesso em: 17 jun. 2021.
SOUSA, F. Entendendo as entradas analógicas do Arduino. 2013. Disponível

em: https://www.embarcados.com.br/arduino-entradas-analogicas/. Acesso em:
16 jun. 2021.
STROSCHON, G. R. Motor de passo arduino – o que é? Como funciona? Que

driver escolher? 2019. Disponível em: https://bit.ly/3zTQWC2. Acesso em: 21
jun. 2021.
THOMSEN, A. Controlando um LCD 16×2 com Arduino. 2011. Disponível em:

https://www.filipeflop.com/blog/controlando-um-lcd-16x2-com-arduino/. Aces-
so em: 22 jun. 2021.
192

Teoria de Microcontroladores e Microprocessadores

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Teoria de Microcontroladores e Microprocessadores

Enviado por

Direitos autorais:

Formatos disponíveis

Teoria de

Revisão, Diagramação e Produção:

Ficha catalográfica elaborada na fonte pela Biblioteca Dante Alighieri

Costa, Kevin Rabelo

Teoria de microcontroladores e microprocessadores. / Kevin

192 p.; il.

1. Monitoramento de dados. - Brasil. II. Centro Universitário

De modo a facilitar o seu entendimento, este livro foi dividido em

A Unidade 1 apresenta um panorama histórico do desenvolvimento

Na Unidade 2, nós estudaremos a programação de dispositivos

Na Unidade 3, desenvolveremos nossos primeiros projetos práticos,

Pretendemos, assim, caro acadêmico, contribuir com a sua formação

Prof. Kevin Rabelo

Na Educação a Distância, o livro impresso, entregue a todos os acadêmicos desde 2005, é

Assim, a UNIASSELVI, preocupando-se com o impacto de nossas ações sobre o ambiente,

Aproveito o momento para convidá-lo para um bate-papo sobre o Exame Nacional de

Olá, acadêmico! Iniciamos agora mais uma disciplina e com ela

Com o objetivo de enriquecer seu conhecimento, construímos, além do livro

Conte conosco, estaremos juntos nesta caminhada!

TÓPICO 1 — HISTÓRIA DOS MICROCONTROLADORES

TÓPICO 2 — ARQUITETURA DE UM MICROPROCESSADOR.............................................. 19

TÓPICO 3 — O MICROCONTROLADOR ATMEGA328............................................................. 41

UNIDADE 2 — PRIMEIROS PASSOS NA PROGRAMAÇÃO

TÓPICO 1 — INTRODUÇÃO À LINGUAGEM DE PROGRAMAÇÃO C++........................... 71

TÓPICO 2 — APRESENTAÇÃO DA PLACA DE DESENVOLVIMENTO ARDUINO.......... 97

TÓPICO 3 — CONFIGURANDO E CONHECENDO A IDE DO ARDUINO........................ 109

UNIDADE 3 — DESENVOLVIMENTO DE PROJETOS COM ARDUINO............................ 133

TÓPICO 1 — SIMULANDO O ARDUINO ATRAVÉS DO TINKERCAD.............................. 135

TÓPICO 2 — EXPLORANDO RECURSOS NATIVOS DO ARDUINO.................................. 151

TÓPICO 3 — PROJETOS COM SENSORES E ATUADORES................................................... 167

HISTÓRIA E ARQUITETURA DOS

• conhecer a evolução da tecnologia de microprocessadores e microcon-

TÓPICO 1 – HISTÓRIA DOS MICROCONTROLADORES e

Preparado para ampliar seus conhecimentos? Respire e vamos

HISTÓRIA DOS MICROCONTROLADORES E

O estudo histórico dos microprocessadores e microcontroladores

Pensando nisso, você estudará como os computadores se desenvolveram

Há ainda quem afirme que os computadores surgiram da necessidade de

FIGURA 1 – PASCALINE, DURANTE MUITO TEMPO FOI CONSIDERADA A PRIMEIRA

FONTE: <https://www.britannica.com/technology/Pascaline>. Acesso em: 23 mar. 2021.

Os cartões perfurados no qual os teares são baseados foram utilizados ainda

Um dos primeiros computadores à válvula conhecido foi o famoso

Mesmo com a capacidade de programação, os computadores anteriores

FIGURA 2 – ESTADOS DE CONDUÇÃO DE UM RELÉ

a) Estado 0: a bobina desenergizada b) Estado 1: a energização da bobina

3 EIS QUE SURGEM OS TRANSISTORES

Basicamente, o transistor é um dispositivo eletrônico composto por

Tudo bem, mas você deve se perguntar o que levou os transistores a

A dopagem eletrônica é o procedimento em que um determinado material

Como você deve lembrar, as portas lógicas desempenham papel

A fim de ampliar os conhecimentos acerca dos transistores e a sua importância

FIGURA 3 – IMPLEMENTAÇÃO DE UMA FIGURA 4 – IMPLEMENTAÇÃO DE UMA

FONTE: O autor (2021) FONTE: O autor (2021)

O surgimento dos transistores proporcionou um grande avanço na

Conforme afirma Pereira (2009), o primeiro microprocessador foi lançado

FIGURA 5 – INTEL I4004: CONSIDERADO O PRIMEIRO MICROPROCESSADOR DA HISTÓRIA.

FONTE: <https://bit.ly/376u8Tw>. Acesso em: 15 jul. 2021.

O i4004 deu início a um intenso desenvolvimento tecnológico nos

O i8008 foi o percursor de um dos microprocessadores mais importantes

enquanto o Macintosh da Apple foi equipado com os processadores 6800 da

Foi com base no i8080 que surgiram a família de processadores x86. O

Ao contrário dos microprocessadores, um microcontrolador já possui

Os primeiros microcontroladores derivaram também do i8080. Chips

Nos anos subsequentes, os microcontroladores continuaram evoluindo