Microcontroladores e AppInventor

Microcontroladores e Automação Residencial –
Introdução ao Controlado de Elementos via

Dispositivos Android
Autores: Pedro Ventura de Oliveira

Autores: Pedro Luiz Fernandes da Silva
Orientador: Luciano Vieira Lima
Uberlândia, setembro de 2018.

Sumário
1. Introdução ........................................................................................................................... 1
1.1. Justificativa .................................................................................................................. 1
2. Conceitos Básicos de Eletricidade e Eletrônica com analogia Hidráulica ............................ 3
2.1. Condução hidráulica continua ...................................................................................... 3
2.2. Condução elétrica continua.......................................................................................... 5
2.3. Condução hidráulica alternada..................................................................................... 6
2.4. Condução elétrica alternada ........................................................................................ 9
2.5. Fluxo hidráulico em sentido único ................................................................................ 9
2.6. Fluxo de elétrons em sentido único .............................................................................10
2.7. Resistencia hidráulica .................................................................................................11
2.8. Resistencia elétrica .....................................................................................................13
2.9. Usando modelo de acionamento para produzir trabalho .............................................17
2.10. Utilizando relé para acionamento de carga..............................................................17
2.11. Controle de fluxo hidráulico através de registro .......................................................18
2.12. Controle do fluxo de elétrons através de transistor ..................................................20
3. ARDUINO ..........................................................................................................................23
3.1. Por que utilizar o Arduino? ..........................................................................................23
3.2. Hardware do Arduino Uno...........................................................................................24
3.3. Shields ........................................................................................................................28
3.4. Arduino IDE ................................................................................................................29
INSTALAÇÃO DO IDE (WINDOWS) ..................................................................................29
INSTALAÇÃO DO IDE (LINUX) .........................................................................................33
Instalação do IDE (MAC OSX) ...........................................................................................34
IDE PORTÁTIL (WINDOWS E LINUX) ..............................................................................36
ARDUINO WEB EDITOR ...................................................................................................37
INTERFACE DO IDE .........................................................................................................37
ii
3.5. Bibliotecas ..................................................................................................................42
BIBLIOTECAS ATRAVÉS DO IDE .....................................................................................42
BIBLIOTECAS EXTERNAS AO IDE ..................................................................................44
3.6. Estruturas condicionais para programação .................................................................46
– IF ....................................................................................................................................46
– FOR ................................................................................................................................48
– WHILE ............................................................................................................................48
– SWICTH/CASE ...............................................................................................................48
3.7. Funções para programação ........................................................................................49
3.8. Variáveis e operadores booleanos, aritméticos e de comparação...............................50
3.9. A programação e erros de conexão ............................................................................51
3.10. Corrigindo problemas de conexão ...........................................................................55
3.11. Criando e executando um sketch ............................................................................59
BLINK ................................................................................................................................59
LEDS ALTERNADOS ........................................................................................................65
SEMAFORO ......................................................................................................................65
SEMAFORO INTELIGENTE ..............................................................................................70
UTILIZANDO O MONITOR SERIAL COM A PROGRAMAÇÃO .........................................72
4. APP INVENTOR: Programação mobile ..............................................................................77
4.1. Por que utilizar o App Inventor? ..................................................................................77
4.2. Acessando ..................................................................................................................78
4.3. Contato inicial .............................................................................................................80
4.4. Novo projeto: duas visões ...........................................................................................81
4.5. Designer .....................................................................................................................84
VIEWER ............................................................................................................................84
PALETTE ...........................................................................................................................85
COMPONENTS E SCREENS ............................................................................................86
PROPERTIES ....................................................................................................................88
iii
MEDIA ...............................................................................................................................89
4.6. Blocks .........................................................................................................................90
BLOCKS ............................................................................................................................90
VIEWER ............................................................................................................................91
4.7. Elaborando projetos ....................................................................................................92
4.8. MIT AI2 Companion ....................................................................................................96
4.9. Criando um aplicativo .................................................................................................97
“HELLO, WORLD!” AO CLICK DE UM BOTÃO .................................................................98
TRANSFORMAR QUALQUER TEXTO EM FALA ............................................................106
ALTERNAR IMAGENS EM TELAS DIFERENTES CLICANDO NUM BOTÃO .................111
ALTERAR IMAGENS NUMA MESMA TELA CLICANDO NUM BOTÃO ..........................117
5. Integração Arduino e App Inventor ...................................................................................124
5.1. Por que integrar as duas plataformas? .....................................................................124
5.2. Comunicação com realimentação efetiva em tempo real ..........................................125
MODELO CLIENTE-SERVIDOR ......................................................................................125
RESPOSTA EM TEMPO REAL .......................................................................................126
5.3. Comunicação via Bluetooth ......................................................................................127
MÓDULO BLUETOOTH RS232 HC-05 ...........................................................................128
DIVISOR DE TENSÃO.....................................................................................................129
MÓDULO RELE ...............................................................................................................130
MONTAGEM DO SISTEMA .............................................................................................132
FUNCIONAMENTO DO SISTEMA...................................................................................134
PROGRAMAÇÃO NO ARDUINO .....................................................................................136
DESENVOLVIMENTO DO APLICATIVO NO APP INVENTOR........................................142
5.4. Comunicação via Ethernet e roteador .......................................................................152
SHIELD ETHERNET ........................................................................................................152
iv
DESENVOLVIMENTO DO APLICATIVO .........................................................................162
5.5. Comunicação via GSM .............................................................................................168
SHIELD GSM/GPRS SIM900...........................................................................................169
DESENVOLVIMENTO DO APLICATIVO .........................................................................179
5.6. Mecanismos de realimentação..................................................................................185
REED-SWITCH................................................................................................................186
SENSOR DE CORRENTE POR EFEITO HALL ...............................................................187
6. Utilizando microcontroladores ARM STM32F1XX ............................................................188
MICROCONTROLADOR STM32F103C8T6 ....................................................................188
BOOT MODES.................................................................................................................190
ST-LINK ...........................................................................................................................191
6.1. Por que utilizar o STM32F103C8T6 ..........................................................................192
6.2. Utilizando o microcontrolador STM32F1 com o ST-LINK ..........................................192
PREPARANDO O ARDUINO IDE ....................................................................................193
DRIVER PARA ST-LINK/V2 .............................................................................................196
PROGRAMANDO O MICROCONTROLADOR COM O ST-LINK .....................................200
6.3. Utilizando o microcontrolador STM32F1 sem o ST-LINK ..........................................202
POSSÍVEIS ERROS AO FINALIZAR OS PROCEDIMENTOS .........................................214
PROGRAMANDO O MICROCONTROLADOR DIRETAMENTE NA PORTA USB...........216
6.4. Aplicação e particularidades .....................................................................................217
6.5. Comunicação via Bluetooth ......................................................................................218
PROGRAMAÇÃO NO ARDUINO IDE ..............................................................................224
6.6. Comunicação via Ethernet ........................................................................................228
v
PROGRAMAÇÃO NO ARDUINO IDE ..............................................................................231
7. O microcontrolador NodeMCU ESP8266 .........................................................................235
7.1. Por que utilizar o ESP8266? .....................................................................................236
7.2. Utilizando o microcontrolador NodeMCU ..................................................................236
7.3. Comunicação via Wi-Fi .............................................................................................242
WEB SERVER EM REDE LOCAL ...................................................................................244
WEB CLIENT CONCECTANDO-SE AO SERVIDOR VIA INTERNET ..............................249
7.4. Comunicação pela nuvem utilizando aREST ............................................................260
UTILIZANDO O AREST NO ARDUINO ...........................................................................260
UTILIZANDO A AREST ...................................................................................................263
8. Microcontroladores nos dias de hoje ................................................................................275
9. ANEXOS ..........................................................................................................................276
Anexo I – Tabela de Modelos de Arduino e suas Especificações ........................................276
Anexo II – Modelos de Shields para Arduino .......................................................................285
Anexo III – Datasheets relevantes .......................................................................................287
Anexo IV – Exemplo de Automação Residencial utilizando ESP8266 e aREST Cloud ........300
vi
1. Introdução
O propósito desse livro é trazer conhecimentos básicos sobre o uso de placas

microcontroladoras no âmbito da automação residencial. Serão apresentados conceitos básicos
relevantes para a montagem de experimentos, tornando o aluno capaz de elaborar os seus
próprios, conceitos sobre o uso de um ambiente de desenvolvimento integrado e linguagem de
programação associada, tornando o aluno capaz de iniciar seus primeiros códigos capazes de
controlar elementos de uma residência, e conceitos sobre uma plataforma de desenvolvimento
de aplicativos, tornando o aluno capaz de elaborar APPs que se comuniquem com o sistema de
automação.
Além disso, serão apresentados alguns tipos de placas microcontroladores que podem ser
utilizadas no âmbito da automação residencial, tornando o aluno capaz de programa-las e
controlar elementos associados as mesmas através de um aplicativo ou web browser.
1.1. Justificativa
A bagagem mobile com a qual os estudantes chegam numa instituição de ensino é enorme.
O uso de smartphones e tablets pelas pessoas já vem de berço e, ao entrar numa faculdade de
engenharia, abdicar de toda essa bagagem com que os alunos chegam não é uma das melhores
ideias para o ensino de diversas disciplinas.
Além disso, a utilização de dispositivos móveis faz parte do dia a dia e a utilização de
computadores e notebooks está cada vez mais em desuso, salvo para a elaboração de trabalhos
que exigem suas capacidades. O que queremos é manter a rotina e utilização dos dispositivos
móveis, acrescentando uma forma de aplicação útil dos mesmos.
Assim, a partir da apresentação do conteúdo de maneira simples ao aprendizado, o aluno
terá conhecimento dos conceitos mínimos necessários para que desempenhem, posteriormente
e com mais facilidade, atividades na construção de tipos básicos de sistemas de automação
residencial. E de posse desses conhecimentos, eles poderão partir para aplicações mais
complexas em disciplinas que exigem um conhecimento mais profundos.
De posse do seu dispositivo móvel, o aluno será capaz de realizar o controle de cargas em
sua própria residência e, além disso, aprenderá sobre questões de confiabilidade dos resultados
do seu controle. Ou seja, será capaz de verificar se, ao solicitar uma ação, ela foi executada
como pretendida, garantindo segurança das ações a serem realizadas.
1
Por fim, a partir do que aqui será exposto espera-se que a aquisição desses conhecimentos
desperte o interesse não apenas em automação residencial, mas em microcontrolados, IoT
(Internet of Things) e áreas associadas, agregando conhecimento e motivando na busca por
maior competência em cursos como Engenharia da Computação, Engenharia de Controle e
Automação, Engenharia Mecatrônica, dentre outras.
2
2. Conceitos Básicos de Eletricidade e Eletrônica com analogia
Hidráulica
A melhor forma de entender o funcionamento do fluxo elétrico é compararmos com o fluxo

hidráulico uma vez que o fluido é visível e elétrons não são.
Quando pensamos em fluxo devemos entender que existe um elemento que cause o
fluxo, ou melhor, a condução. Na hidráulica utilizam-se frequentemente canos ou mangueiras, já
na eletricidade utilizam-se fios ou cabos. Vamos entender como funciona o fluxo hidráulico.
2.1. Condução hidráulica continua
Tomemos como exemplo duas caixas dágua (Fig. 2.1):
Figura 2.1. Ilustração de uma caixa d'água cheia e uma vazia.
Para transferir água de uma caixa para outra precisaremos de um condutor de água, como
por exemplo, um cano (Fig. 2.2).
Figura 2.2. Ilustração de um cano.
3
O cano conduz com facilidade a água, pois ele é oco e liso não oferecendo oposição ao fluxo
de água. Se colocarmos o cano na parte superior da caixa somente um pouco de água irá passar
de uma caixa para a outra e o fluxo irá parar rapidamente fazendo com que o objetivo não seja
atingido, não se transferirá toda a quantidade de uma caixa para outra (Fig. 2.3).
Figura 2.3. Caixas d'água com cano na parte superior.
Se colocarmos o cano na parte inferior as duas caixas ficarão com a mesma quantidade de
água e quando isso acontecer o fluxo deixara de acontecer e o objetivo não será atingido pois
não se transferiu toda a quantidade de uma caixa para outra.
Figura 2.4. Caixas d'água com cano na parte inferior.
Se colocarmos as caixas em alturas diferentes (caixa com água mais alta que a caixa
sem água) a água irá fluir para a caixa mais baixa (Fig. 2.5). O tempo gasto neste processo
dependerá da espessura interna do cano e da diferença de altura entre as duas caixas.
Figura 2.5. Caixas d'àgua com extremidades do cano em alturas diferentes.
4
Com isso conclui-se que:
 A água sempre irá da caixa mais alta para a caixa mais baixa desde que haja um condutor
interligando-as;
 A agua naturalmente irá do potencial mais alto para o potencial mais baixo;
 Sem diferença de potencial (neste caso a altura) não existe fluxo de água;
 O fluxo acaba quando acabar (esvaziar) a água da caixa de potencial mais alto ou quando
for retirado o elemento condutor, neste caso o cano;
 Quanto mais fino o condutor (cano) menor é o fluxo de água e maior é a resistência à
passagem de água;
 O fluxo não depende do tamanho das caixas e sim da diferença de potencial (altura) entre
elas.
2.2. Condução elétrica continua
Da mesma forma que temos fluxo de água no condutor hidráulico (cano) temos o fluxo
ordenado de partículas portadoras de carga elétrica no condutor elétrico (fio). Esse fluxo se dá
pela diferença de potencial elétrico nas extremidades do condutor elétrico, como pode ser visto
na Fig. 2.6 à seguir:
Figura 2.6. Fluxo de partículas portadoras de carga elétrica.
5
Para que um material seja condutor é preciso que o mesmo atenda uma propriedade
física chamada condutividade. Condutividade é a capacidade dos materiais de conduzirem
corrente elétrica. Quanto à condutividade os materiais podem se classificar em:
 Condutores – Que conduzem naturalmente corrente elétrica;
 Semicondutores – Necessitam de estímulo via diferença de potencial (DDP) para
conduzirem;
 Isolantes – Não conduzem corrente elétrica.
Nesse capítulo será tratado o funcionamento do material condutor.

Ao se ligar um condutor e uma fonte de energia, como uma pilha, por exemplo, o
comportamento dos elétrons no sentido convencional se dará do polo positivo (+) para o negativo
(-), conforme Fig. 2.7 a seguir.
Figura 2.7Sentido convencional de corrente elétrica contínua.
A essa forma de movimento ordenado dá-se o nome de corrente elétrica contínua ou

corrente direta.
A diferença de potencial elétrico é representada pela tensão e expressa em Volt (V). O
fluxo de elétrons é denominado de corrente elétrica e expressa em Àmpere (A).
2.3. Condução hidráulica alternada
No item “2.1. Condução Hidráulica Contínua” foi demonstrado o fluxo de água de uma
caixa d’água A para uma caixa d’água B. Nesse caso, percebe-se que a água flui apenas em
uma direção, pois há uma diferença de altura entre as caixas d’água. Agora será demonstrado
como se obtém o fluxo nas duas direções.
Supõem-se duas caixas de água conforme apresentadas na Fig. 2.8.
6
Como pode ser visto a caixa d’água A está mais alta que a caixa d’água B. Isso implica
no fluxo natural da caixa d’água A para a caixa d’água B.
Figura 2.8. Fluxo de água da caixa d'água A para a caixa d'água B.
Se após a caixa d’água B estiver cheia houver a elevação da altura da mesma em relação
a caixa d’água A que vai estar vazia, ocorrerá o processo inverso, o fluxo de água ocorrerá da
caixa d’água B para a caixa d’água A, conforme Fig. 2.9 a seguir.
Figura 2.9. Fluxo de água da caixa d'água B para a caixa d'água A.
Se este movimento for constante, a troca de altura entre as caixas assim que a caixa de
altura superior estiver vazia, produzirá um fluxo constante ordenado de um lado para o outro
conforme Fig. 2.10 a seguir.
7
Figura 2.10. Ciclo de fluxo de água entre as caixas d'agua.
Dessa forma é possível imaginar as caixas subindo e descendo continuamente ao longo

do tempo, conforme Fig. 2.11 a seguir.
Figura 2.11. Fluxo d’água entre as caixas. Observa-se um movimento análogo ao senoidal.
8
2.4. Condução elétrica alternada
Agora que está entendido o fluxo de água de uma caixa d‟água A pra outra caixa d‟água
B e vice-versa em um movimento e vai e vem constante, fica fácil imaginar o movimento dos
elétrons quando se trata de corrente alternada.
A corrente elétrica alternada varia o sentido do fluxo dos elétrons ao longo do tempo. A
forma de onda mais usual é a senoidal, em forma de senóide conforme Fig. 2.12.
Figura 2.12. Forma de onda senoidal da corrente elétrica.
Como os elétrons vão de um potencial mais alto para o potencial mais baixo, fica claro
que essa variação de potencial ocorre constantemente invertendo assim o sentido do fluxo dos
elétrons. Na maioria dos países da América, inclusive Brasil e EUA a frequência da rede elétrica
é 60 Hz. Isso significa que o fluxo de elétrons inverte seu sentido 60 vezes a cada segundo.
2.5. Fluxo hidráulico em sentido único
Em instalações hidráulicas às vezes e necessário ordenar o fluxo de água em um único

sentido visando com isso a proteção do sistema contra o refluxo da água. Para isso utiliza-se um
equipamento chamado válvula de retenção e seu esquema pode ser visto na Fig. 2.13.
9
Figura 2.13. Esquema mecânico de uma válvula de retenção.
O funcionamento é bem simples. Em função do tipo de válvula que possuem permitem o

deslocamento da água num só sentido. É necessário observar que a instalação deve ser feita de
modo a que a portinhola abra no sentido do fluxo. Caso retorne água no sentido inverso a
portinhola se fecha e o fluxo é interrompido.
Esse equipamento pode ser visto na Fig. 2.14. Observe que existe uma seta indicando o
sentido natural do fluxo e, portanto, orientando o modo de instalação.
Figura 2.14. Foto de uma válvula de retenção. Fonte: http://buttbrothers-

valves.com/index.php?id_category=45&controller=category. Acessado em out/2018.
2.6. Fluxo de elétrons em sentido único
Em elétrica e eletrônica geralmente se faz necessário a garantia do fluxo de elétrons ou

corrente elétrica em um único sentido, ora para proteger o circuito, ora para ordenar a corrente
10
elétrica. No primeiro caso temos a proteção e, no segundo, temos a retificação que nada mais é
que a utilização da corrente em um único sentido, descartando, assim, a corrente no sentido
contrário.
Para isso, utiliza-se um componente chamado “diodo” e seu símbolo eletrônico bem como
a representação de um modelo convencional em eletrônica pode ser visto na Fig. 2.15.
Figura 2.15. Simbologia e representação do diodo.
2.7. Resistencia hidráulica
Normalmente uma tubulação não oferece resistência à passagem de fluído, não há

obstáculos que dificultam a passagem do fluído em seu interior visto que o material geralmente
é liso, sem rugosidades ou imperfeições. Isso quer dizer que a todo o conteúdo será transportado
do ponto A ao ponto B conforme Fig. 2.16.
Figura 2.16. Passagem de água pelo tudo sem atrito.
11
Dessa forma fica fácil entender que caso haja algum obstáculo no interior do tubo ou
mesmo acúmulo de algum tipo de sujeira no mesmo a passagem do fluído ficará comprometida
como pode ser visto na Fig. 2.17.
Figura 2.17. Tubo com obstrução interna. Fonte: http://www.narrowpathplumbing.com/helpful-

tips/clogged-drains/. Acesso em out/2018.
Da mesma forma se o tubo estiver com dano físico, amassado, criará também uma
oposição à passagem do fluído conforme Fig. 2.18.
Figura 2.18. Cano amassado.
Às vezes é preciso criar uma resistência hidráulica para que se possa diminuir o fluxo de água
em determinadas situações. Para isso emprega-se o uso um componente chamado redução e
seu esquema pode ser visto na Fig. 2.19 e um exemplar do memso em Fig. 2.20.
12
Figura 2.19. Esquema de redução hidráulica.
Figura 2.20. Redução hidráulica. Fonte: http://hidraulicapotenza.com.br/produto/predial/buchas-de-

reducao. Acesso em out/2018.
2.8. Resistencia elétrica
Por definição resistência elétrica é a capacidade de um corpo qualquer se opor à

passagem de corrente elétrica mesmo quando existe uma diferença de potencial aplicada. Nos
condutores o movimento dos elétrons acontece de forma desordenada, o que caracteriza em
uma dificuldade de locomoção interna, acarretando em colisões com outros elétrons e átomos
deste condutor. Dessas colisões há também uma dificuldade na passagem dos elétrons,
estabelecendo então que a corrente elétrica que ali flui tenha uma resistência.
13
Figura 2.21. Comportamento dos eletrons no condutor metálico. Fonte:
http://biocasantanabloguefq.blogspot.com.br/2014_05_01_archive.html. Acesso em out/2018.
Em condutores metálicos como o alumínio, cobre e outros, há alguns fatores que

determinam o valor de sua resistência, como:
 Área do condutor: Quanto maior, menor é a resistência e quanto menor a seção maior
é a resistência.
 Comprimento: Quanto maior o comprimento do condutor maior será a resistência,
pois os elétrons terão um longo caminho a ser percorrido.
 Tipo de material: Quanto mais elétrons livres estiverem neste material condutor
menor será a resistência elétrica e maior será a passagem de corrente elétrica.
Nos circuitos elétricos e eletrônicos geralmente necessitamos inserir componentes para
promover uma queda de tensão e, consequentemente, limitação de corrente. Para isso,
utilizamos resistores elétricos, comumente chamados de resistências, cujo unidade é dada em
ohms (Ω). A seguir, a Fig. 2.22 nos mostra o simolo e um modelo convencional de resistor.
Figura 2.22. Simbolo de um resistor e um resistor convencional.
O seu valor nominal é apresentado por faixas coloridas (código de cores), que obedecem
ao seguinte critério: partindo da extremidade, as duas primeiras cores formam um número com
14
dois algarismos; a terceira cor corresponde ao expoente da potência de 10 que multiplica o
número inicial; a quarta cor corresponde à tolerância que mostra, percentualmente, a faixa de
valores em que pode variar a resistência do resistor. A tabela a seguir mostra o código de cores
com suas correspondências.
Alguns resistores são dotados de cinco faixas, ao invés de quatro. Nesses casos, as três
primeiras cores irão formar um número de 3 algarismos e as faixas seguintes sequem o mesmo
princípio já exposto (multiplicador e tolerância). A imagem a seguir traz um exemplo de tabela de
cores para resistores.
Figura 2.23. Código de cores para resistores. Fonte:

http://squids.com.br/arduino/index.php/tabelas/tabela-de-resistores. Acesso em out/2018.
Com um tabela dessas podemos agora calcular o valor de um resistor. Tomemos como
exemplo o resistor da Fig. 2.24 para verificarmos o seu valor.
15
Figura 2.24. Resistor de 47000 ohms.
As duas primeiras cores, Amarelo (4) e Violeta (7), formam o número 47. A terceira cor,
laranja (3), corresponde ao expoente da potência de dez: 103; a quarta cor, prata (10%), indica a
tolerância. Assim, a resistência elétrica é: 47103Ω (ou 47000Ω ou, ainda, 47kΩ) ± 10%.
Uma vez que foram apresentados todos os modelos ficam claras as suas associações e
intuitivas as relações de proporção de acordo com a Primeira e Segunda lei de Ohm.
A Primeira Lei de Ohm postula que para um condutor ôhmico (resistência constante),
mantido à temperatura constante, a intensidade de corrente elétrica será proporcional à diferença
de potencial (ddp) aplicada entre suas extremidades. É representada pela seguinte fórmula:
𝑈
𝑅=
𝐼
Onde:
R – resistência, medida em Ohm
U – ddp, medida em Volts (V)
I – intensidade de corrente elétrica, medida em Àmpere (A).
A Segunda Lei de Ohm estabelece que a resistência elétrica de um material é diretamente

proporcional ao seu comprimento, inversamente proporcional à sua área de secção transversal
e depende do material do qual é constituído, sendo representada pela seguinte fórmula:
𝜌∗𝐿
𝑅=
𝐴
Onde:
R – resistência (Ω)
ρ – resistividade do condutor (depende do material e de sua temperatura), medida em Ohm
por metro (Ω.m)
L – comprimento, em metros (m)
A – área de secção transversal, em milímetros quadrados (mm2).
16
2.9. Usando modelo de acionamento para produzir trabalho
Uma das máquinas hidráulicas mais simples inventadas pelo homem, o monjolo (Fig.
2.25) chegou ao Brasil com os portugueses durante o período colonial. E, por muito tempo,
tornou-se ferramenta indispensável na lida, pois dispensava o uso de mão-de-obra escrava, que
antes socava e moía os grãos em pilões.
Figura 2.25. Monjolo. Fonte: http://revistagloborural.globo.com/GloboRural/0,6993,EEC1689831-

4528,00.html. Acesso em out/2018.
A força da queda d'água o impulsiona como se fosse uma gangorra. De um lado, uma
concha recebe a água até se encher totalmente. Isso faz com que a outra parte do monjolo, onde
há uma estaca, se levante. Ao esvaziar a cuba, o movimento se inverte. E nesse sobe-e-desce,
o grão vai sendo socado e moído dentro de um pilão. Obviamente que a tarefa é mais demorada,
se comparada ao uso de equipamentos elétricos.
O funcionamento deste equipamento mostra claramente a utilização de um tipo de
acionamento (hidráulico) produzindo um trabalho (mecânico).
2.10. Utilizando relé para acionamento de carga
Da mesma forma que foi mostrado o monjolo e seu modelo de acionamento separado do
trabalho, na eletrônica também são usados componentes com essa função onde o acionamento
é isolado da carga. A esse componente dá-se o nome de relé e pode ser visto na Fig. 2.26.
17
Figura 2.26. Relé e suas esquematizações. Fonte:
http://eletronicaemcasa.blogspot.com/2013/12/como-acionar-um-rele-com-arduino-ou-pic.html.
Acesso: out/2018.
A bobina é o principal componente do relé. É em torno dela que é gerado um campo

eletromagnético quando o relé é energizado. Este campo eletromagnético gera uma força capaz
de movimentar um conjunto mecânico (armadura fixa) com contatos móveis alterando assim seu
estado de normalmente aberto para fechado ou de normalmente fechado para aberto de acordo
com o tipo de relé, por exemplo.
A ideia de se utilizar um rele é que se pode acionar uma carga com grande potência a
partir de um comando de pequena potência. Sua aplicação é baseada no acionamento por
corrente contínua (5V, 12V ou 24V) para atuar em cargas de corrente contínua que exijam grande
fluxo de carga bem como em corrente alternada (127V e 220V).
2.11. Controle de fluxo hidráulico através de registro
Quando se precisa controlar e/ou dosar a quantidade de fluxo hidráulico em uma

tubulação utiliza-se um equipamento chamado registro. Existem registros de vários modelos e
para várias aplicações. Um modelo convencional chamado registro de gaveta pode ser visto na
Fig. 2.27.
18
Figura 2.27. Registro de gaveta. Fonte: https://www.leroymerlin.com.br/registro-de-gaveta-rotativo-
32mm-ou-1-docol_86943913. Acesso em: out/2018.
Basicamente o registro irá funcionar de 3 formas:

 Totalmente fechado – neste caso nenhum fluxo de água passará, ele estará
impedindo o fluxo completo;
 Totalmente aberto – neste caso todo o fluxo de água passará, ele permitirá o fluxo
completo;
 Ajustável manualmente – neste caso o operador dosa a intensidade do fluxo de água
que passará pela tubulação através da abertura gradativa até atingir a quantidade
desejada.
O sistema de vedação e funcionamento pode ser visto na Fig. 2.28.
Figura 2.28. Constituição interna do registro de gaveta. Fonte:

https://www.leroymerlin.com.br/registros-de-gaveta. Acesso em: out/2018.
19
Como pode ser visto, conforme se gira o registro a passagem de água é obstruído ou
liberado aos poucos.
2.12. Controle do fluxo de elétrons através de transistor
Nos circuitos eletrônicos geralmente há a necessidade de cortar, liberar ou até mesmo

dosar a quantidade do fluxo de elétrons em um determinado ramo do circuito. Para isso emprega-
se o componente chamado transistor.
O transistor é um componente eletrônico que começou a popularizar-se na década de
1950. São utilizados principalmente como amplificadores e interruptores de sinais elétricos,
podendo ter variadas funções. Alguns modelos podem ser vistos na Fig. 2.29.
Figura 2.29. Modelos de transistors. Fonte:

https://tmgeletronica.com.br/Produto.aspx?IdProduto=3321&IdProdutoVersao=3321. Acesso em
out/2018.
20
O recurso consiste em uma pequena partícula de material semicondutor como o silício ou
germânio, cuja capacidade de conduzir corrente elétrica se situa entre as dos
materiais condutores e isolantes. Cada transistor tem três terminais, como se fossem canais,
que recebem o nome de “emissor”, “coletor” e “base” podendo se apresentar de dois modos
distintos baseados na ordem em que os materiais semicondutores se organizam no componente
(PNP ou NPN) os quais podem ser vistos na Fig. 2.30.
A classificação NPN e PNP é baseada no tipo do material semicondutor empregado.
Observando a letra do meio pode-se dizer qual o tipo do material da base, a qual é o registro do
transistor, sendo assim, se for tipo N significa que é controlado por carga negativa, ser for tipo P
significa que é controlado por carga positiva.
Figura 2.30. Simbologia de transistors NPN e PNP.
Um dos terminais (coletor) recebe a tensão elétrica, e o outro envia o sinal amplificado
(emissor). Já o canal do meio (base) – também conhecido como terminal de controle – é o
responsável por fazer a mediação deste processo, uma vez que a corrente elétrica só entra e sai
pelos condutores das pontas somente quando o do meio recebe uma tensão elétrica. Portanto,
ele que faz o controle do processo. A quantidade de tensão aplicada ao terminal do meio
determinará qual será a intensidade da corrente que sairá pelo terminal de saída.
Em computadores e sistemas microcontrolados o transistor não é empregado como
amplificado, ele trabalha como chave, pois controlam a chamada “lógica binária” ou “lógica
digital” para executarem suas operações internas.
A lógica digital é um ramo peculiar da lógica matemática que por sua vez é um ramo da
lógica formal. A peculiaridade consiste no fato de que suas variáveis podem assumir apenas dois
valores mutuamente exclusivos: verdadeiro ou falso, jamais um valor intermediário.
Estes dois valores são usados para representar os algarismos “um” e “zero” empregados
nas operações internas dos computadores. Desta forma podemos afirmar que “Verdadeiro = 1”
21
e “Falso = 0” e, apenas com estes dois algarismos, representar todos os números no sistema
numérico binário, ou de base 2.
22
3. ARDUINO
O Arduino é uma plataforma de prototipagem sendo, nesse quesito, utilizada tanto para
testes quanto para o planejamento e desenvolvimento de projetos. É uma placa com
microcontrolador, capaz de comandar e responder à estímulos de elementos externos
conectados ao mesmo.
Nesse livro, o objetivo do uso desse e de outros microcontroladores é o de criar
ferramentas que são acessíveis, de baixo custo, flexíveis e fáceis de usar por profissionais,
amadores e, principalmente, para aqueles que não teriam alcance aos controladores mais
sofisticados e de ferramentas mais complexas.
Esse material trás em específico algumas informações referentes a versão do
microcontrolador denominado Arduino Uno, e todas as implementações realizadas que
envolverem a plataforma serão relativos ao modelo nesse capítulo.
Para mais informações sobre modelos de Arduino consulte o Anexo I
3.1. Por que utilizar o Arduino?

Os argumentos para utilizar a plataforma de desenvolvimento são diversos e serão citados
abaixo:
 Open Source (ou Código Aberto);

A tradução de open source seria Fonte Aberta ou Código Fonte Aberto o que na verdade
vai mais além do que isso. Resumidamente podemos citar os dez quesitos que o fazem ser
Open Source:
1. Distribuição livre;
2. Acesso ao código-fonte;
3. Permissão para a criação de trabalhos derivados;
4. Integridade do autor do código-fonte;
5. Não discriminação contra pessoas ou grupos;
6. Distribuição da licença;
7. Licença não específica a um produto;
8. Licença não restritiva a outros programas;
9. Licença neutra em relação a tecnologia.
23
 Praticidade;
Por ser uma plataforma de desenvolvimento completa com os circuitos básicos
necessários (controladores de tensão, comunicação serial, clock, ...) torna-se prático o
desenvolvimento e teste de projetos.
 Escalabilidade;
Por ser de fácil integração com placas de expansão é possível o empilhamento de
placas e recursos, tornando o projeto adaptável a mudanças e melhorias.
 Diversidade de modelos;
Com um número superior a 20 modelos existentes no mercado, as opções de escolha
para um determinado projeto ficam evidentes.
 Diversidade de Shields.
Uma grande variedade de placas de expansão está disponível no mercado.
3.2. Hardware do Arduino Uno

A placa que constitui o Arduino Uno é dotada de entradas e saídas (I/O) digitais e,
também, de entradas analógicas, entrada USB e tomada de energia que aceita uma tensão de
entrada (recomendada) entre 7 e 12v, corrente continua. A mesma opera na tensão de 5V (pinos
I/O) e suporta correntes de 20mA em cada pino sendo, também, capaz de operar em 3,3V num
pino específico para tanto, suportando 50mA.
Figura 3.1. Arduino Uno. Fonte: disponível em <https://store.arduino.cc/usa/arduino-uno-rev3>,

Acessado em: set/2018.
24
Cada pino do Arduino Uno possui internamente um resistor de pull-up com resistência de
20-50kΩ e que estão desabilitados, por padrão, mas que podem ser habilitados via software.
Além disso, alguns desses pinos possuem algumas funções únicas:
 Comunicação serial: os pinos 0 (RX) e 1 (TX) são responsáveis pela recepção e
transmissão, respectivamente, serial de dados. Os mesmos realizam a
comunicação USB com o computador do usuário e, sendo assim, é necessário
que estejam livres de qualquer conexão no momento da compilação de um
programa desse computador para a placa para que não ocorram erros.
 Interrupção externa: quando desejamos que uma atividade seja interrompida para
que outra seja realizada podemos executar essa ação programando o pino 2 ou 3
para tanto.
 PWM: os pinos 3, 5, 6, 9, 10 e 11 permite uma saída PWM (Modulação por Largura
de Pulso, do inglês Pulse-Width Modulation) de 8-bits e pode ser utilizado para
controlar o nível de tensão do pino, por exemplo.
 SPI: um protocolo de dados serial que permite que o Arduino se comunique com
outros dispositivos formando uma rede de arquitetura mestre-escravo entre eles.
Utiliza, para tanto, os pinos 10, 11, 12 e 13.
 LED: O pino 13 é capaz de controlar um LED construído na própria placa
alternando o nível de tensão que passa pelo mesmo para ligar ou desligar o
componente.
Ainda sobre os pinos, é interessante saber que os analógicos fornecem uma resolução
de 10-bits do valor de tensão que passa por eles. Isso significa que o valor de tensão pode ser
dividido numa faixa de até 1024 valores (0 à 1023).
O microcontrolador do Arduino Uno possui uma memória flash1 de 32 KB, sendo que 0.5
KB já estão em uso pelo bootloader2. Embora possa parecer uma memória muito pequena, ela
é suficiente para o desenvolvimento de aplicações diversas e mais que suficiente para os projetos
que serão desenvolvidos aqui.
As placas Arduino em seus diferentes modelos possuem uma extensa documentação,
indo bem além do que já foi aqui exposto. Afim de não delongar e tomar foco no que é de
interesse nesse material, outras informações relativas ao Uno (e outros modelos), além de
detalhamento mais aprofundado, podem ser melhor verificada no site: https://www.arduino.cc/.
1 A flash é uma memória não volátil onde os softwares elaborados são armazenados.
2 O bootloader é um software pré-gravado executado ao ser dado o boot (um reset) na placa e é
responsável por carregar na memória Flash um programa que é recebido pela porta serial e também pela
sua execução. Caso não haja um programa a ser carregado, é feita uma procura já na memória buscando
a existência prévia de algum software para execução.
25
A seguir, na Fig. 3.2., algumas características importantes sobre a placa de prototipagem
em questão.
Figura 3.2. Características Importantes do Arduino UNO. Fonte: disponível em:

<http://digital.csic.es/bitstream/10261/127788/7/D-c-%20Arduino%20uno.pdf>. Acessado em:
ago/2018.
Informações técnicas e a pinagem do microcontrolador são apresentadas em Fig. 3.3 e

Fig. 3.4.
26
Figura 3.3. Informações técnicas, em resumo, do Arduino Uno. Fonte: disponível em:
https://store.arduino.cc/usa/arduino-uno-rev3. Acessado em: set/2017.
Figura 3.4. Pinagem do Arduino Uno R3. Fonte: <https://github.com/Bouni/Arduino-Pinout>.

Acessado em: set/2017.
27
3.3. Shields
Embora o Arduino seja um microcontrolador útil para diversas aplicações, cada versão
da plataforma possui suas limitações. Para tornar possível a conexão com uma rede local ou
facilitar a utilização de um motor, por exemplo, são utilizados os chamados shields.
Um shield é uma placa de circuito que funcionam como uma extensão do Arduino, sendo
acoplados aos mesmos, aprimorando suas capacidades num dado aspecto. Para utiliza-los é
comumente incluído na programação alguma biblioteca específica que habilitam e facilitam as
funcionalidades da placa específica para uma dada atividade.
Mas adiante, alguns shields e módulos serão utilizados nos experimentos elaborados
para demonstrar aplicações do microcontrolador nesse livro.
Para informações acerca dos diversos shields existentes, consulte o Anexo II
Figura 3.5. Exemplos de alguns shields. Da esquerda para direita e de cima para baixo temos os
shields: GSM/GPRS, para motores, Ethernet e de relês.
28
3.4. Arduino IDE
O Arduino pode ser programado através de seu Ambiente de Desenvolvimento Integrado

(do inglês Integrated Development Environment – IDE), um software que pode ser encontrado
para download no site do fabricante.
Esse software do microcontrolador pode ser utilizado em diferentes sistemas operacionais
(Windows, Linux, OSX) e conta, também, com um editor web, guardando todos os dados e
projetos desenvolvidos e em desenvolvimento na nuvem. Possui uma interface simples e uma
programação baseada em C/C++, além de ser open source, possuindo bibliotecas não apenas
próprias do desenvolvedor, mas de terceiros, que podem ser importadas e utilizadas por qualquer
pessoa facilitando o desenvolvimento de códigos.
Lembrando que não apenas o software como também o hardware são open source e
suas especificações podem ser encontradas facilmente na internet.
INSTALAÇÃO DO IDE (WINDOWS)

A partir da página “https://www.arduino.cc/en/Main/Software” podemos encontrar todas
as possibilidades de acesso ao IDE do Arduino.
Para que possamos realizar seu download e instalação no Windows devemos selecionar,
em “Download the Arduino IDE”, uma das três possibilidades que envolvem a plataforma.
Figura 3.6. Recorte da página de downloads. À direita, as opções de download do programa para
Windows, Mac e Linux.
Recomenda-se o download do instalador (“installer”, primeira opção) pela facilidade de

instalação e localização dos arquivos de instalação, mas o arquivo compactado (“ZIP file”) pode
29
ser de interesse a criação de uma instalação portátil que será explicada mais adiante. O
download pela Microsoft Store exigiria acesso e permissões à pasta referente aos seus
aplicativas que, inicialmente, já é ocultada pelo próprio sistema operacional. Tais contratempos
para acessar, adicionar, remover, editar etc, elementos da IDE são desnecessários sendo, por
isso, o “installer” a melhor opção.
Ao clicar em uma delas, seremos redirecionados para uma página de contribuição para
com o software. Aqui, devemos selecionar “just download”, caso não haja interesse em
contribuição financeira, ou em “contribute & download”, caso haja.
Figura 3.7. Recorte da página de solicitação de doação antes do download propriamente dito do
Arduino IDE.
Referente à primeira opção (“Windows installer”), localize em seu computador o destino

do arquivo instalador que foi baixado e, ao executa-lo, devemos permitir que o mesmo tenha
acesso ao computador e realize alterações no mesmo.
30
Figura 3.8. Ícone do instalador do Arduino IDE após download.
Figura 3.9. Tela do Windows 10 de solicitação de permissão ao aplicativo.
Em seguida, uma janela aparecerá com os termos referente a licença do software e nela
devemos (após a leitura, caso seja de interesse) selecionar “I Agree” para seguir em frente.
31
Figura 3.10. Tela do acordo de licença do software do Arduino.
Feito isso será apresentada uma nova janela para seleção de instalação de componentes
na qual devemos clicar em “Next >” para prosseguir.
Figura 3.11. Componentes a serem instalados na máquina referentes ao IDE.
Por fim, a instalação será iniciada após a escolha do local de destino das pastas do
software, na qual podemos deixar a pasta escolhida por padrão e clicar em “Install”.
32
Figura 3.12. Janela de seleção da pasta de destino na qual os arquivos necessários para o
funcionamento da IDE serão instalados.
Finalizado o procedimento, clicaremos em “close” e buscaremos pelo programa com o

símbolo do Arduino para darmos início a programação dos projetos desejados.
Figura 3.13. Ícone do atalho criado na área de trabalho referente ao Arduino IDE.
A instalação pela loja do Windows procede como a instalação dos demais aplicativos
provenientes da mesma, sendo gerado um ícone para o aplicativo, e com a utilização da interface
funcionando da mesma maneira. Como já dito, ela só não é a instalação mais recomendada
devido as dificuldades de acesso as pastas da raiz do Arduino IDE que, como veremos mais
adiante, podem ser importantes e tornar as coisas mais práticas.
INSTALAÇÃO DO IDE (LINUX)

A instalação em Linux o pacote não necessita de nenhuma atenção especial dependendo
da distribuição utilizada, mas sim referente a arquitetura do sistema operacional: 32bit, 64bit ou
ARM (ver Fig. 3.6).
Verificada a versão correta e selecionando-a, seremos levados a página de doação na
qual devemos escolher a opção de download e salvar o arquivo. O arquivo baixado deverá ser
descompactado.
33
Figura 3.14. Arquivo compactada e pasta após descompactação de uma versão do Arduino IDE 1.8.
Abrindo a pasta descompactada, devemos localizar o arquivo “install.sh” e clicar no

mesmo com o botão direito; a opção “Run in Terminal” do menu que será apresentado e deve
ser selecionada. A instalação será iniciada e, ao finalizar, um ícone referente ao IDE será criado
na área de trabalho.
Caso haja algum problema na instalação devemos seguir, pelo próprio terminal do Linux
até a pasta do Arduino (possivelmente a pasta descompactada terá um nome como arduino-
1.8.x) e utilizar o comando “./install.sh” (sem as aspas) para que o procedimento seja realizado.
Há ainda a possibilidade de o sistema não permitir o acesso às portas seriais de
comunicação entre o Arduino e o computador com distribuição Linux. Nessa situação, o próprio
site do Arduino instrui que seja digitado, no terminal, o comando:
ls -l /dev/ttyACM*
Ao executar o comando uma mensagem semelhante deve aparecer:
crw-rw---- 1 root dialout 188, 0 5 apr 23.01 ttyACM0
E o nome usuário da máquina deve ser acrescentado ao grupo “dialout” como se segue:
sudo usermod -a -G dialout <username>
Por fim, é necessário deslogar e logar novamente o usuário para que as alterações sejam
aplicadas e a comunicação serial possa ser utilizada normalmente.
Instalação do IDE (MAC OSX)

Para uma máquina com sistema operacional Macintosh o procedimento é um pouco mais
simples. Ao selecionar a opção de versão (ver Fig. 3.6) e iniciar o download por meio de uma
das opções na página de doação, como já falado anteriormente nos outros processos de
instalação, devemos extrair o arquivo baixado ou apenas expandido (isso dependerá do
navegador utilizado).
34
Figura 3.15. Aplicativo já extraído após Download. Fonte:
https://www.arduino.cc/en/Guide/MacOSX. Acesso: ago/2018.
O arquivo de aplicação do Arduino deve então copiado para uma pasta de interesse da
máquina como, por exemplo, a de Aplications e o procedimento de instalação está finalizado.
Figura 3.16. Ícone do software pronto para uso no MAC OSX.
35
IDE PORTÁTIL (WINDOWS E LINUX)
É um método utilizado e recomendado em situações onde o uso do IDE se faz num
ambiente onde o usuário não tem privilégios de administrador sobre a máquina que utiliza, como
acesso a pastas, instalação de pacotes, dentre outros. Dessa maneira, a melhor forma para se
proceder é possuir uma versão portátil da IDE.
Para tanto, é necessário realizar o download da pasta compactada (.ZIP) referente ao
sistema operacional utilizado e sua arquitetura específica. Feito isso, iremos descompacta-lo
numa pasta de destino ou pendrive.
Na pasta raiz criaremos um novo diretório denominado “portable”, junto das demais
pastas.
De agora em diante, ao iniciarmos o executável do Arduino, também contido na raiz, o
diretório “portable” será preenchido com bibliotecas, projetos, etc. pertinentes aos
desenvolvimentos realizados.
Figura 3.17. Raiz da IDE já com o novo diretório criado. Identificamos também, na raiz, o executável
do Arduino para iniciar o software.
No caso do lançamento de uma nova versão do IDE podemos proceder de duas

maneiras: extraindo a pasta compactada da nova versão e copiando o diretório “portable” da
versão antiga para a mais recente ou ainda copiando todos os arquivos da nova versão para a
antiga, sobrescrevendo os mais antigos.
36
ARDUINO WEB EDITOR
Além de todas as opções de download do IDE para a elaboração de códigos para o
Arduino existe também a possibilidade de acesso online ao ambiente. Podemos ver essa como
sendo a primeira opção na página do software: https://www.arduino.cc/en/Main/Software.
Figura 3.18. Página de Downloads do Arduino IDE. Acima das opções de download é apresentada
a opção de utilizar o Arduino Web Editor.
O editor faz parte da plataforma Create (https://create.arduino.cc/) e é uma ferramenta

relativamente recente (informações a respeito datam de novembro de 2016) e com muito a ser
explorado e apresentado não cabendo, no momento, ao propósito desse material.
INTERFACE DO IDE
Ao iniciar o programa pelo seu atalho ou executável a interface do Arduino será
carregada e a mesma é como se segue na Fig. 3.19. Nela, temos:
1. o menu principal, cujas opções serão esclarecidas adiante;
2. uma barra de ferramentas com botões;
3. a região de abas e menu acerca das mesmas;
4. a área de trabalho onde o código será elaborado;
5. a área de mensagens de erros e notificações pertinentes ao código
desenvolvido;
6. informações sobre a porta de comunicação serial que está utilizando.
37
1
2
3
5
6
Figura 3.19. Visão da interface de programação do IDE.
O menu de opções (1) agrega questões diversas gerais do arquivo do projeto e auxilio no
texto do código.
O menu “Arquivo” lida com as questões de salvamento do projeto, iniciação de um novo,
manipulação de preferências de layout da janela, visualização dos já criados em sketchbook,
além de exemplo disponibilizados pela própria plataforma de diversos projetos possíveis.
38
Figura 3.20. Menu "Arquivo" do IDE.
Figura 3.21. Exemplos do menu "Arquivo". Uma série de exemplos são disponibilizados facilitando
o entendimento sobre diversas funções do software.
39
Em “Editar” temos opções de desfazer ou refazer alterações enquanto estamos editando
o código, seleções e colagem do código, localização e substituição, identação, modificação do
texto para comentário e alteração do tamanho de fonte.
Figura 3.22. Menu "Editar" do IDE.
O “Sketch” (rascunho) é mais voltado para a verificação, compilação, inclusão de

bibliotecas e arquivos e outras opções voltadas para o funcionamento e execução do projeto.
Figura 3.23. Menu "Sletch" do IDE.
40
O menu “Ferramentas” envolve algumas questões primordiais como a seleção da placa
que estamos utilizando, a porta serial que a placa está utilizando para sua comunicação, bem
como um monitor serial do que está ocorrendo durante a comunicação, dentre outras questões.
Figura 3.24. Menu "Ferramentas" do IDE.
Por fim, em “Ajuda” temos informações sobre o Arduino, seu ambiente, auxilio para
iniciantes dentre outras opções relacionadas.
Figura 3.25. Menu "Ajuda" do IDE.
41
No que diz respeito a barra de ferramentas (2) a mesma agrega, respectivamente,
questões relativas a checagem do código por erros, compilação e carregamento do código para
o Arduino, criação de novo Sketch (arquivo para escrita do código), abertura de aba mostrando
os projetos já salvos, salvamento do que está sendo escrito e, por fim, o monitor serial, onde
informações da comunicação entre máquina e Arduino podem ser mostrados.
Verificar Carregar Salvar Serial Monitor
Novo Abrir
Figura 3.26. Os botões, da esquerda para direira: verificar, carregar, novo, abrir, salvar e monitor
serial.
As demais áreas relevantes serão apresentadas mais adiante conforme convir e for
necessário.
Faremos, a seguir, uma breve leitura de questões importantes voltadas a programação,
para que tenhamos uma noção da forma de escrita e estruturas importantes para tanto.
3.5. Bibliotecas
Uma biblioteca é um conjunto de funções que tornam mais simples o desenvolvimento de

um software por prover aos usuários de serviços sem que o mesmo precise passar por toda uma
complexa e trabalhosa desenvoltura de seu código para utilizar algo que já existe (partir da roda,
sem necessitar de reinventa-la).
O Arduino é dotado de uma certa quantidade de bibliotecas, estendendo seu ambiente e
capacidades, sendo utilizadas para, por exemplo, manipulação de dados e trabalho com algum
shield.
Para utilizar uma biblioteca podemos agregar ao código uma existente na própria
plataforma, fazer o download de alguma outra ou criar nossa própria biblioteca de acordo com
nossas necessidades.
BIBLIOTECAS ATRAVÉS DO IDE

Pelo próprio software podemos utilizar bibliotecas já inclusas em “Incluir Biblioteca” no
menu “Sketch”. Ao clicar em uma das bibliotecas da lista, serão inseridos os arquivos de
42
cabeçalho (.h) referentes a pasta da mesma. A inclusão é feita através das declarações
“#include”.
Figura 3.27. Caminho para inclusão de bibliotecas já existentes no IDE. Selecionaremos a biblioteca
"Ethernet".
Podemos adicionar ao código apenas parte dos cabeçalhos de uma biblioteca, caso tenhamos a
certeza de que nem todas as inclusões feitas ao selecionarmos o item da lista de bibliotecas
serão necessárias. Isso diminui o consumo de memória quando o programa for compilado para
o Arduino.
Figura 3.28. Linhas de código acrescidas após seleção da biblioteca "Ethernet" para inclusão.
43
Pelo IDE podemos também utilizar o “Gerenciar Bibliotecas...” e, através dele, realizar o
download e instalação de uma biblioteca disponível.
Figura 3.29. Gerenciador de Biblioteca aberto após selecionar a opção, da lista de bibliotecas,
"Gerenciar biblioteca...".
Para isso, é necessário uma conexão com a internet que possibilite o download e, ao
localizar a biblioteca de interesse, basta escolher a versão desejada e clicar no botão “Instalar”.
Quando a instalação for finalizada, é possível verificar a palavra “INSTALLED” e a versão
instalada ao lado do nome da biblioteca e, assim, podemos fechar a janela do gerenciador.
Figura 3.30. A biblioteca cuja instalação foi solicitada apresenta a mensagem "INSTALLED" e a
versão, quando a instalação é finalizada, ao lado do nome da mesma.
BIBLIOTECAS EXTERNAS AO IDE

Podemos, também, realizar a instalação de bibliotecas que não estejam listadas pela
base do software seja a mesma de um terceiro desconhecida ou elaborada por nós mesmos.
Para isso, podemos, através de um arquivo compactado contendo a pasta da biblioteca, clicar
em “Adicionar biblioteca .ZIP”, que é uma opção da lista de bibliotecas. Feito isso e selecionada
44
o arquivo compactado devemos clicar em “Abrir” e a biblioteca será incluída no banco sendo
mostrada na lista.
Figura 3.31. Janela aberta para a seleção do .ZIP para inclusão na lista de bibliotecas.
Uma outra forma de inclusão seria realiza-la manualmente. Para tanto, precisamos extrair
a pasta compactada da biblioteca e encontrar um local no qual a biblioteca pode ser administrada
pelo Arduino IDE, como o Sketchbook onde cada sketch criado é armazenado por padrão.
A pasta descompactada contém todos os arquivos necessários para o funcionamento da
biblioteca e o local para instalação pode ser encontrado no menu “Arquivo” em “Preferências”.
Localizado o caminho que, por padrão, é “..\<nome do usuário>\Documents\Arduino” (no
Windows) devemos acessar a pasta “libraries” e copiar a pasta da biblioteca no local.
Figura 3.32. Janela de preferências do Arduino IDE, onde podemos verificar o local de
armazenamento dos projetos (Sketchbook).
45
Figura 3.33. Pasta copiada para "libraries", onde o Arduino IDE terá acesso para utiliza-la nos
projetos a serem desenvolvidos.
Devemos tomar atenção a alguns detalhes no que diz respeito as bibliotecas salvas no
sketchbook:
 A versão da biblioteca utilizada num novo sketch será aquela salva em “libraries”
do sketchbook, mesmo que uma versão mais atualizada esteja presente na
distribuição do IDE ou nos arquivos principais do programa;
 Quando o programa passa por uma atualização, todas os arquivos do local onde
a instalação do Arduino IDE foi realizada são deletados e substituídos. Dessa
forma, a preservação das bibliotecas instaladas e utilizadas por um dado usuário
dependem de o mesmo te-las devidamente colocadas em seu sketchbook, o que
evita que as mesmas sejam perdidas no processo.
3.6. Estruturas condicionais para programação
As estruturas condicionais são aquelas que possibilitam a execução de determinadas

ações após a verificação de uma dada condição como sendo verdadeira ou não. Algumas delas
fazem a verificação dos dois casos sendo uma ação executada não só para um deles, mas para
ambos.
– IF
Estrutura utilizada para realizar comparações e, caso a condição dada seja satisfeita, uma
ação será executada. Podemos utilizar o “if” de diferentes maneiras sendo essas variações
dependentes do que se deseja obter com as comparações.
A forma básica para utilizar o if é como se segue:
46
if (comparação a ser obedecida){
//ação a ser realizada
}
Podemos alterar a composição da estrutura tornando-a composta de forma a agregar

condições possíveis , caso a inicial não tenha sido obedecida, em sequência, utilizando “else” ou
ainda um conjunto de “else if” finalizando com “else” quando uma estrutura com mais de duas
condições é elaborado. Veja:
if (comparação 1){
}
else (comparação 2){
}
Ou, como também foi dito:
if (comparação 1){
}
else if (comparação 2){
}
...
else (comparação n){
}
Seria possível realizar uma sequência de condições utilizando apenas a estrutura “if”.
Porém, o uso do “else” torna o programa mais rápido quando as ações realizadas têm suas
condições interligadas.
Podemos utilizar o seguinte exemplo para compreender melhor: havendo uma ação a ser
realizada dependente de um valor numérico a ser recebido pelo programa, se uma comparação
entre o valor esperado e o valor recebido for satisfeita no primeiro “if” utilizado, “else” e os “else
if” em sequência (caso haja) não serão executados, pois são comparações que só ocorrem caso
uma anterior não tenha sido satisfeita. Sendo assim, satisfeita a comparação em algum ponto,
as demais não serão verificadas, pois não há necessidade para tanto.
Diferentemente do cenário observado no exemplo, usando apenas a estrutura “if”, todas
as comparações seriam feitas, mesmo que a condição de uma delas já tivesse sido satisfeita o
47
que, dependendo do tamanho e complexidade do projeto, pode não ser interessante e
desperdiçar recursos.
– FOR
Estrutura utilizada para realizar controle do fluxo do programa. O mesmo permite a
realização de repetições dum conjunto de instruções de acordo com alguns parâmetros pré-
estabelecidos. O que o diferencia de outras estruturas de loop (repetição) é uso de um contador
incremental ou de decremento, sendo recomendado quando a quantidade de repetições do loop
é sabida. Sua forma é como se segue:
for (inicialização; condição; incremento){

//declaração de instruções
}
– WHILE
Estrutura de controle de fluxo que realiza um loop, por tempo indefinido, das instruções
dentro do seu bloco de declaração. Quando a expressão de condição é verdadeira o programa
entrará naquela estrutura de repetição e apenas sairá quando a expressão for falsa. Sendo
assim, uma condição interna ou externa ao loop, como o incremento de uma variável, teste de
um sensor ou outra condição de parada.
É interessante notar que um for-loop pode ser passado como um while-loop e vice-versa,
sendo a diferença entre eles a questão de quantidade de repetições definida e indefinida de suas
instruções internas.
O “while” é construído como se segue:
while (expressão de condição){

}
– SWICTH/CASE
Realizam controle de fluxo de maneira análoga ao “if”. Trabalha com casos, os quais são
selecionadas de acordo com o valor de uma variável a ser testada. Assim, dado um valor
referente a variável de teste, o valor será comparado com sua resposta específica que é atribuída
a cada caso. Veja:
48
switch (variável){
case valor1:
break;
case valor2:
break;
default:
//instruções para caso nada mais se encaixe
}
No código, o comando break para o teste do switch e, caso não fosse utilizado ao final de
cada caso, a execução se perpetuaria até o final do fluxo. O comando pode ser utilizado nas
demais estruturas de repetição como uma condição de parada, interrompendo o loop.
3.7. Funções para programação
Funções são estruturas portadoras de um conjunto de instruções que realizam uma

determinada tarefa e, quando executadas, retornam um resultado, voltando para a área do
código da qual a mesma foi previamente evocada.
São criadas como uma maneira de facilitar o uso de um dado conjunto de instruções que
são frequentemente utilizadas no código de forma a não tumultua-lo, deixando o código mais
limpo e simples de entendimento. Além de auxiliar na organização, as linhas de código ficam
diminutas, diminui a chance de erro por não ser necessário escrever o mesmo conjunto de
instruções diversas vezes no programa, fazendo com que elas sejam debuggadas também
apenas uma vez, dentro outras comodidades.
O software do Arduino possui diversas funções prontas que facilitam o uso da plataforma,
seja para acessar um pino e definir seu modo de funcionamento, abrir a comunicação serial do
microcontrolador, enviar comandos ou outras coisas de mesma ou maior complexidade. Das
mais básicas, podemos citar:
 pinMode() – configura o pino especificado para que se comporte como uma
entrada ou saída de dados e também pode ativar o resistor de pullup do mesmo;
 digitalRead() – lê o valor de um pino digital especificado (como sinal de alta,
HIGH, ou baixa, LOW);
 digitalWrite() – escreve um valor de sinal alto ou baixo (nível lógico);
 analogRead() – lê o valor de um pino analógico especificado. O Arduino pode
mapear valores de 0V à 5V numa faixa de 10bits, devido seu conversor
49
analógico-digital. Isso permite uma leitura de 1024 valores (entre 0-1023), ou
seja, numa resolução de 0,49mV;
 analogWrite() – escreve um valor analógico num pino;
 Serial.begin() – estabelece a taxa de transferência de dados seriais, em bits
por segundo;
 Serial.available() – pega o número de bytes disponível para leitura à partir
de uma porta serial;
 delay() – para o programa por uma determinada quantidade de tempo que
deve ser especificada em milisegundos.
3.8. Variáveis e operadores booleanos, aritméticos e de comparação
Variáveis são objetos que retêm uma expressão ou valor, o qual pode ser pré-
estabelecido ou vindos de alguma leitura ou retorno de resultado, por exemplo.
Existem diversos tipos de variáveis e as mesmas devem ser declaradas antes de serem
utilizadas, ou seja, terem um tipo definido e, caso seja de interesse, inicializada (estipulada com
um valor inicial). Algumas dos tipos de dados comumente utilizadas no Arduino são:
 int – para declaração de números inteiros;
 Float – para declaração de números de ponto flutuante;
 Char – para declaração de um caractere ASCII a ser armazenado em um byte
de memória;
 String – conjunto de zero ou mais caracteres;
 Boolean – para declarar uma variável que pode ser atribuída de apenas dois
valores: true(verdadeiro) e false (falso).
Tendo em vista o que é uma variável booleana, um operador booleano são aqueles que
verificam uma condição como sendo verdadeira ou falsa. São empregados na programação do
Arduino em estruturas “if” para verificar a condição estabelecida.
Os operadores são:
 && – representa o “e” lógico, sendo verdadeiro apenas quando duas condições
são verdadeiras;
 || – representa o “ou” lógico, sendo verdadeiro se uma das condições for
verdadeira;
 ! – representa o “não” lógico, sendo verdadeiro se a condição apresentada for
falsa;
50
Os operadores aritméticos são aqueles aplicados em operações matemáticas envolvendo
variáveis. São eles:
 Igualdade (=);
 Adição (+);
 Subtração (-);
 Multiplicação (*);
 Divisão (/);
 Resto da divisão (%).
Por fim, os operadores de comparação fazem o que o nome sugere: comparam duas
variáveis, sendo bastante utilizados nas estruturas condicionais. São os que seguem:
 Igual a (==);
 Diferente (!=);
 Menor que (<);
 Maior que (>);
 Menor ou igual a (<=);
 Maior ou igual a (>=).
3.9. A programação e erros de conexão
Na Fig. 3.34 observamos, na região do código, duas estruturas denominadas setup() e

loop() /. As mesmas são imprescindíveis para o funcionamento do programa, acarretando em
erro, ao não serem localizadas no código.
Em setup() é feita a configuração inicial dos parâmetros que serão utilizados na
programação como o modo dos pinos, inicialização da comunicação serial etc.
Em loop() são realizadas as repetições, ou seja, é onde o código terá suas linhas
executadas indefinidamente em ciclos.
Externamente, outras funções podem ser criadas, tendo seu retorno aplicado em uma
das duas estruturas principais, dependendo do interesse do programador.
Dito isso, para a programação no IDE utilizaremos das estruturas, funções e variáveis
bases apresentadas nos itens anteriores, dentre outros, no interior das estruturas setup() e loop()
bem como, também, de funções desenvolvidas foras delas, mas que retornam para uma das
mesmas, prosseguindo com a sequência das instruções a serem executadas.
51
Figura 3.34. Interface com alguns comentários sobre as regiões de programação do IDE.
Terminado o programa e feita a verificação de erros no código – ao clicar no primeiro

botão da barra de ferramentas –, iremos estabelecer em “ferramentas”, no menu, a placa e porta
de comunicação utilizadas para o projeto. Devemos ter ciência de qual modelo do Arduino –
Uno, Mega, Nano etc – estamos utilizando, pois, embora possa ser possível compilar o programa
para o microcontrolador carregando a informação incorreta sobre a escolha da placa, algumas
funções e características exclusivas de uma dada placa podem ficar comprometidas devido a
isso causando um comportamento inesperado.
Como apresentado na Fig. 3.36, abaixo da opção de seleção de placa, temos a seleção
da porta, que ficará com seu texto “apagado” (desabilitado) enquanto o microcontrolador não
estiver conectado via USB ao computador. Sem a seleção correta da porta (COM), o programa
não poderá ser compilado para placa devido a uma falha de comunicação adequada entre
Arduino e computador.
Em caso de falha de reconhecimento do dispositivo ao computador, tente conectar a placa
nas demais portas USB do mesmo. Não obtendo sucesso: desconecte-a, utilize o comando
52
“Windows + x” (em máquinas com sistema operacional Windows) e selecione a opção
“Gerenciador de Dispositívos”, localize a opção de “Controladores USB”, clique com o botão
direito em “Verificar se há alterações de hardware” para tentar solucionar o problema e conecte
a placa novamente.
Figura 3.35. Início da verifiação do código (à esquerda) e mensagem de finalização da compilação

(à direita) sem ocorrência de erros.
53
Figura 3.36. Lista de seleção de placas do menu em "Ferramentas" > "placa:". Abaixo da opção de
seleção, verifica-se que “Porta” está desabilitada.
Figura 3.37. Gerenciador de Dispositivos, onde "Controladores USB" pode ser localizado.
Solucionados os problemas de conexão, com o Arduino ligado ao computador via USB,

podemos realizar a execução do programa clicando em “Carregar” (segundo botão da barra de
ferramentas). Essa ação pode ou não alertar sobre outros possíveis erros os quais, dessa vez,
podem estar associados à seleção incorreta de qual placa/porta está sendo utilizado ou também
problemas com a própria placa, como a falta de algum driver ou como falha na comunicação com
o bootloader.
54
3.10. Corrigindo problemas de conexão
Os últimos problemas citados ocorrem comumente ao utilizarmos versões clone do Arduino.

Essas são mais baratas que a genuína por não usarem o chip USB-Serial FTDI3, mas uma versão
funcional de baixo custo do chip: o CH340. Por sua vez, esse chip necessita da instalação de um
driver no computador de uso e, em certas ocasiões, também é necessário a instalação do
bootloader do Arduino na versão clone por ser ele o responsável pelo upload e execução dos
programas que desejamos repassar ao microcontrolador.
A figura a seguir nos mostra como localizar a informação do chip de comunicação que está
sendo usado. Caso seja identificado o CH340 e sua máquina não reconheça o Arduino ao ser
conectado na USB, podemos acessar o site:
http://www.wch.cn/download/CH341SER_EXE.html, realizar o download do driver necessário,
clicando no botão azul com símbolo de uma nuvem com uma seta para baixo, localiza-lo na pasta
de destino de seus downloads e instala-lo. Alternativamente, utilize o site:
https://pandoralab.com.br/arduino/driver-ch340-para-arduino/, em português e com link direto
para download para outras distribuições de sistemas operacionais.
Figura 3.38. Localização e identificação do chip de comunicação USB-Serial.
3 Empresa especializada em tecnologia que oferece, dá suporte e desenvolve produtos, muitos deles
voltados na conversão de algum sinal para sinais de USB. A sigla FTDI, significa “Future Technology
Devices International”
55
Figura 3.39. Recorte da página http://www.wch.cn/download/CH341SER_EXE.html. Clicando no
botão azul, destacado em vermelho, o driver para Windows do CH340 será baixado.
Figura 3.40. Localizado o arquivo baixado, dê um clique duplo com o botão esquerdo, aguarde o
carregamento e solicitação de permissão e, após fornecer permissões, clique em "INSTALL" e siga
com o procedimento de instalação.
Em alguns casos, ainda será necessário a instalação do bootloader para que o

microcontrolador possa, finalmente, funcionar. A forma mais simples para isso seria utilizando de
um Arduino que esteja funcionando normalmente (se possível uma distribuição genuína do
mesmo).
Esse Arduino funcional deve ser conectado ao USB e, em seguida, iremos selecionar no
menu “Arquivo”, o exemplo “ArduinoISP”. No menu de ferramentas iremos clicar no segundo
botão para carregar o código (após verificado placa/porta) que foi aberto do exemplo na placa e
desconecta-la do computador.
56
Figura 3.41. Caminho do código exemplo que deve ser carregado na placa.
Agora iremos realizar conexões entre os dois Arduinos:

 Os pinos 5V, GND, 11, 12 e 13 devem ser interligados;
 O pino 10 da placa funcional deve ser conectado ao pino Reset da que desejamos gravar
o bootloader;
 Em alguns casos, o funcionamento correto do procedimento no Arduino UNO necessita
que um capacitor de 10µF seja conectado entre o Reset e o GND do microcontrolador
funcional.
57
Arduino funcional
Arduino sem bootloader
Figura 3.42. Esquema das conexões a serem feitas pra carregamento do bootloader.
Para finalizar, iremos reconectar o Arduino funcional ao computador via USB. Vá em

“Ferramentas” no menu do IDE e, dessa vez, selecione o modelo da placa que deseja carregar
o bootloader (anteriormente utilizamos a placa funcional). Novamente em “Ferramentas”, iremos
em “Gravar Bootloader”.
Certifique-se de que “Programador” estará como “ArduinoISP” no menu “Ferramentas” e,
acabado esse procedimento, o Arduino Uno estará pronto para ser utilizado.
Figura 3.43. Selecionamos "Gravar Bootloader" e, em seguida, devemos abrir o menu novamente
para verificar a opção "Programador" (opção acima de gravar).
58
3.11. Criando e executando um sketch
Partindo do que foi apresentado até o momento serão elaborados alguns projetos
envolvendo o microcontrolador Arduino Uno, os componentes eletrônicos que já foram discutidos
inicialmente (resistores, díodos, etc), além de alguns outros elementos que serão explicados
conforme seus casos de uso forem apresentados.
BLINK
Diferente do que acostumamos a fazer quando iniciamos nossos estudos numa nova
linguagem de programação, quando se trata do Arduino o projeto inicial equivalente ao “Hello,
World!” consiste em fazer um LED piscar (blink).
Um LED (Light Emitting Diode) é um diodo que emite luz quando é energizado. O mesmo
tem uma ordem correta de conexão (por ser um diódo), é polarizado, possuindo um de seus
pinos de conexão maior que o outro, normalmente, sendo o ânodo (lado positivo) a perna maior
e o cátodo (lado negativo), a menor. Dependendo do tamanho do LED é possível verificar com
uma certa facilidade os polos pelas partes internas dentro do componente sendo o positivo e o
negativo, respectivamente, o lado menor e o maior.
Figura 3.44. Representação esquemática de um LED (à esquerda) e ilustração de seus polos e

formas de identifica-los. Fonte: https://www.seattleu.edu/scieng/ece/student-resources/laboratory-
resources/components/. Acesso em: outubro, 2017.
Na Fig. 3.44 também é mostrada mais à direita uma terceira forma de identificação dos
polos na qual, pelo invólucro de vidro, o pino referente a parte chanfrada (achatada) é o negativo.
Não existe uma função específica que faça um LED piscar e, sendo assim, é necessário
desenvolver um código que faça o trabalho utilizando das demais funções, estruturas, etc. que o
ambiente de desenvolvimento nos propicia. A imagem a seguir ilusta as necessidades do código.
59
Figura 3.45. Ciclo de ações necessárias para fazer um LED piscar.
O próprio IDE traz alguns exemplos de aplicações da placa, como falado anteriormente.
Então, nesse caso, não precisaremos escrever o código para testar a aplicação. Iremos iniciar o
programa e acessar o menu “Arquivo” > “Exemplos” > “01. Basics” > “Blink”. Será então aberta
uma nova janela com o código Blink carregado e comentado com um cabeçalho inicial e cada
linha do mesmo, informando sobre suas funções.
Figura 3.46. Caminho para acessar o exemplo "Blink" no Arduino IDE.
60
Figura 3.47. Nova janela do Arduino IDE, com o exemplo "Blink" aberto.
É importante, como mostrado em Blink, realizar comentários ao longo do código para que
informações importantes sobre o mesmo não sejam esquecidas e para que outras pessoas que
tiverem acesso ao mesmo possam melhor compreende-lo. Para tanto, utilizamos duas barras
(//), quando o comentário é feito em apenas uma linha e, para uma dada quantidade de linhas
ser comentada, podemos ou iniciar cada linha com as barras ou utilizar uma barra e asterisco ao
início da região e um asterisco e barra, ao final (/* */).
No programa teremos, em setup(), a inicialização de elementos relacionados a placa. No
caso fez-se uso da função pinMode, que toma como argumentos o pino desejado que, nesse
caso, foi o LED_BUILTIN, e como o pino será utilizado, para saída de dados (OUTPUT).
A maioria dos Arduinos possui um pino conectado a um LED da própria placa e ligada em
série a um resistor. Conforme já identificado na Fig. 3.2., o modelo Uno tem esse componente
próximo ao pino 13. Sendo assim, LED_BUILTIN é o nome dado ao pino que está associado a
esse LED.
As declarações realizadas com a função pinMode fazem, então, com que o pino 13 haja
como uma saída de sinal digital, entregando ao circuito conectado ao mesmo um nível lógico
alto, 5V (binário 1), ou baixo, 0V (binário 0), dependendo da solicitação realizada.
Em loop() foram colocadas as instruções que serão executadas em ciclos indefinidamente
que, nesse programa, seriam as funções digitalWrite e delay. A primeira recebe como
61
argumentos o pino e o nível lógico que será entregue a esse pino e a segunda, o tempo em que
o código ficará sem executar nenhuma ação antes de prosseguir seu ciclo. Por tanto, será
realizado o acionamento do LED da placa, entregando nível alto (HIGH) ao pino 13
(LED_BUILTIN), o mesmo permanecerá ligado por um segundo (1000 milisegundos) e será
então feito o desligamento do mesmo, entregando nível baixo (LOW) ao pino por um segundo.
Figura 3.48. Recorte do IDE, mostrando o código de Blink.
Seguiremos então os passos já ensinados para ver o exemplo em ação: verificar o código,
selecionar a placa/porta de uso e carregar o código.
Está feito! O LED da placa deverá piscar.
1 4
2
3
‘
Figura 3.49. Sequênca dos passos para gravar código na placa microcontroladora. Fazemos a
verificação do código para identificar possíveis erros (1), selecionamos a placa (2) que estamos
utilizando e a porta (3) na qual ela está conectada via USB e, enfim, carregamos o código (4).
62
Podemos realizar o mesmo projeto utilizando outra porta digital qualquer do Arduino. Para
isso precisaremos de:
 1 protoboard;
 1 resistor 360Ω;
 1 LED (5mm);
 2 jumpers (fios conectores) macho-macho.
O protoboard é uma placa para montagens experimentais com conexões condutoras

distribuídas em diversos furos possibilitando sua reutilização para diversos projetos por não
necessitar de soldas. Suas laterais têm conexão horizontal e ao centro, conexões verticais,
conforme a próxima figura ilustra.
Figura 3.50. Protoboard. Trilhas laterais superior e inferior com ligação horizontal, normalmente
utilizadas para conectar polos de alimentação para demais componentes. Conexões verticais mais
ao centro, onde comumente são conectados os componentes.
Por fim, os jumpers são fios conectores e o circuito utilizando-os junto aos componentes
eletrônicos, microcontrolador e protoboard fica como se segue:
63
Figura 3.51. Projeto para piscar LED sem utilizar o componente da própria placa. Aqui, o pino
utilizado para realizar as ações sobre o LED é o 8.
O pino 8, utilizado no exemplo como saída digital, é ligado ao polo positivo do LED e o
negativo é ligado ao resistor que. por sua vez. fechará o circuito ligando-se ao terra (GND) do
Arduino. O resistor é necessário para que não haja problemas quanto a tensão e corrente do
sistema, não ultrapassando os limites do LED. E, para saber que estamos lidando com outro pino
para o acionamento de um outro LED, devemos substituir “LED_BUILTIN” por 8 em todas as
funções.
Figura 3.52. Exemplo Blink editado.
64
LEDS ALTERNADOS
É comum vermos mais de uma lâmpada piscando em situações onde uma sinalização de
alerta é necessária. Em garagens de prédios podemos, por exemplo, observar duas lâmpadas
piscando alternadamente.
Para fazer uma simulação semelhante utilizaremos a montagem feita para o uso de um
LED externo ao da placa (Fig. 3.51) e, para simplificar, o próprio LED da placa. O código é como
se segue:
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
pinMode(8, OUTPUT);
}
void loop() {
digitalWrite(LED_BUILTIN, HIGH);
digitalWrite(8, LOW);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
digitalWrite(8, HIGH);
delay(1000);
}
No código, iremos primeiro declarar na função setup() os modos dos pinos 13 e 8 como
sendo de saída (OUTPUT). Em seguida, em loop(), colocaremos um dos LED’s com sinal de alta
(HIGH) e o outro de baixa (LOW). Essas declarações garantes que um será iniciado aceso e o
outro apagado e, após um atraso de 1 segundo (delay(1000)), invertemos os estados de cada
pino para que o LED aceso apague e o outro acenda.
SEMAFORO
O semáforo consiste no acionamento sequencial de 3 LED’s com o desligamento do
anterior assim que o seguinte é acionado sendo bem semelhante ao código anterior.
Para montagem do circuito do semáforo utilizaremos os mesmos elementos da montagem
anterior, alterando a quantidade de alguns deles e, dessa vez, não utilizaremos o LED interno do
microcontrolador. Assim, precisaremos de:
 1 protoboard;
 1 resistor 360Ω;
 3 LED (5 mm);
 7 jumpers macho-macho;
65
Cada LED será associado a um pino diferente e, por estarem funcionando
alternadamente, podemos utilizar um único resistor conectando o terminal negativo dos mesmos
para fechar o circuito junto ao GND da placa.
Figura 3.53. Montagem do circuito do semáforo.
Cada pino funcionará como uma saída digital e realizará o acionamento e desligamento
sequencial de cada LED. A implementação do delay funcionará como um temporizador do
semáforo.
No código, como será mostrado em breve, será implementada a inicialização de variáveis
sendo dados nomes a cada um dos pinos. No projeto anterior, vimos que o próprio IDE tinha um
nome pré-estabelecido para o pino 13 e, tal como foi feito para esse pino, podemos atribuir nomes
a qualquer outro desde que inicializada uma variável adequadamente.
66
int t1 = 2000; //declaração de varável de tempo
int t2 = 500;
int verde = 8; //declaração do pino 8, 9 e 10
int amarelo = 9; //para os nomes das cores dum semáforo
int vermelho = 10;
void setup(){
//os 3 pinos funcionarão como saídas digitais
pinMode(verde, OUTPUT);
pinMode(amarelo, OUTPUT);
pinMode(vermelho, OUTPUT);
}
void loop(){
digitalWrite(verde,HIGH); //acende verde
delay(t1); //aguarda um tempo
digitalWrite(verde,LOW); //apaga verde e
digitalWrite(amarelo,HIGH); //acende amarelo
delay(t2);
digitalWrite(amarelo,LOW);
digitalWrite(vermelho,HIGH); //o vermelho será o último
delay(t1);
digitalWrite(vermelho,LOW); //o loop garante que, ao
} //apaga-lo, o verde acenderá
Como o tempo do delay e o número dos pinos são valores inteiros, foi feita a inicialização
das variáveis “t1”, “t2”, “vermelho”, “amarelo” e “verde” declarando-as como “int” (valor inteiro).
Os valores dados são referentes aos pinos utilizados e ao tempo de espera desejado entre as
ações do programa.
Até o exemplo anterior, ao escolher o pino que desejávamos utilizar, era necessário, a
cada linha onde sua ocorrência seria dada, escolher o número do pino. Assim, caso fossemos
mudar o pino utilizado, nós deveríamos procurar todos os seus campos e modifica-los com o
novo número. A declaração dos mesmos facilita com que, sendo necessária realizar alguma
alteração, uma modificação possa ser feita de forma mais simples, apenas em uma parte do
código, com menor ocorrência de erros.
Em programas de grande porte, por exemplo, pode não ser tão simples localizar todas as
vezes que o pino 8 foi utilizado, mas se o pino fosse declarado de início bastaria que, no local da
declaração, seu valor fosse alterado de 8 para outro desejado.
67
Outras medidas que podem ser adotadas para clarificar um código é o uso de uma função
própria. No exemplo do semáforo, podemos criar 3 funções, uma para cada cor, e estipular
quanto tempo eles ficarão naquele estado.
O novo código seria como se segue:
int t1 = 2000;
int t2 = 500;
int verde = 8;
int amarelo = 9;
int vermelho = 10;
void setup()
{
}
void loop()
{
luzverde(t1);
luzamarela(t2);
luzvermelha(t1);
}
void luzverde(int tempo){

digitalWrite(verde, HIGH);
digitalWrite(amarelo, LOW);
digitalWrite(vermelho, LOW);
}
void luzamarela(int tempo){
digitalWrite(verde, LOW);
digitalWrite(amarelo, HIGH);
digitalWrite(vermelho, LOW);
}
void luzvermelha(int tempo){
digitalWrite(verde, LOW);
digitalWrite(amarelo, LOW);
digitalWrite(vermelho, HIGH);
}
68
Embora o código tenha ficado mais extenso nessa situação do que na anterior, se
observarmos o loop() podemos notar que o mesmo ficou bastante conciso.
Em algumas situações, para mantermos o código mais limpo e organizado, podemos
fazer, além da criação das funções como mostrado, sua compartimentação em uma nova aba de
código, separando-as de uma maneira ainda mais ordenada e específica tanto das estruturas
principais (setup() e loop()) quanto entre as próprias funções
Para fazer isso, clicaremos na seta para baixo no canto direito da região de abas do IDE
e selecionaremos “Nova Aba” (ou basta o comando Ctrl+Shift+N). Nomeada a nova aba,
podemos levar, por exemplo, as funções criadas para lá e isso não interferirá no funcionamento
do código principal que contém setup e loop, sendo eles mantidos na aba principal.
O salvamento do código criará dois arquivos com a extensão .ino dentro de uma mesma
pasta.
Figura 3.54. Caminho para criação de nova aba.
Figura 3.55. Escolha do nome da nova aba na parte inferior da janela do IDE.
69
Figura 3.56. Visão do código em duas abas.
Figura 3.57. Arquivos do código de semáforo em sua pasta de criação.
SEMAFORO INTELIGENTE
Utilizando a mesma montagem do projeto anterior, com algumas mudanças na
programação, podemos fazer um semáforo inteligente. A consideração de “inteligente” diz
respeito ao piscar progressivamente mais rápido de um LED, previamente à transição para um
outro, como se avisasse que o seu tempo está acabando. Essa progressão ocorre comumente
nas luzes verde e vermelha do sinaleiro e para fazermos esse efeito com LED’s utilizaremos a
estrutura condicional “for”. Veja o programa:
70
int t = 1500;
int verde = 8;
int amarelo = 9;
int vermelho = 10;
void setup()
{
}
void loop()
{
for (int x=1000;x >20; x=x*0.75){ //reduz o delay para piscar
digitalWrite (verde,HIGH); //rapidamente
delay (x);
digitalWrite (verde,LOW);
delay (x);
}
digitalWrite (amarelo,HIGH); //luz amarela representa

delay (t); //uma chamada para ficarmos
digitalWrite (amarelo,LOW); //atentos. Não precisa piscar
delay (t); //progressivamente
for (int z=1000;z>20; z=z*0.75){
digitalWrite (vermelho,HIGH);
delay (z);
digitalWrite (vermelho,LOW);
delay (z);
}
}
Primeiramente, inicializamos algumas variáveis referentes aos pinos e um valor de tempo

que será utilizado. Seguindo para o setup(), configuramos os pinos ligados aos LED’s como
saídas digitais e seguimos para o loop(), já iniciado com um “for”.
Conforme foi apresentado previamente, a estrutura condicional “for” é composta de uma
inicialização, uma condição e um incremento. Foi então inicializada, na primeira condicional, a
71
variável “x” como um inteiro de valor inicial 1000, com condição para que o loop4 prossiga de que
o valor de “x” seja maior que 20 e, ao início de cada nova repetição das instruções dentro da
estrutura, o novo valor da variável seria igual ao seu valor atual multiplicado por 0.75.
Assim sendo, quando a função loop() é iniciada, seguimos direto para o loop do “for” que
consiste em diminuir progressivamente o valor de “x” que, consequentemente, diminuirá o delay
da troca de estado de nível alto para nível baixo do pino “verde” até que a variável atinja um valor
inferior à 20, o que quebra o for-loop e prossegue o programa para as demais linhas do loop().
Passaremos para o LED “amarelo”, com delay simples, e finalizaremos o semáforo
inteligente com a mesma lógica do primeiro LED no pino “vermelho”.
UTILIZANDO O MONITOR SERIAL COM A PROGRAMAÇÃO

Vimos até agora projetos funcionando automaticamente após a compilação para a placa.
Porém, é também possível que o sistema aguarde por algum comando para, verificado o mesmo,
uma ação seja realizada de fato.
Existem diversos componentes que podemos agregar ao sistema e aguardar por um sinal
de entrada digital (INPUT), analógico ou comunicação serial afim de realizar uma ação de acordo
com tal sinal recebido.
Para mostrar essa forma de funcionamento do sistema utilizaremos funções de
comunicação serial do Arduino e o seu monitor serial. Além disso, utilizaremos a estrutura
condicional “if” para que, verificada a condição dada, uma certa ação ocorra.
Veja o programa abaixo, com comentários sobre o mesmo feitos no próprio texto, para
que possamos prosseguir com o assunto.
4
Quando falamos no loop estamos nos referindo a repetição de instruções no interior de uma estrutura/função. Ao falarmos loop(),
queremos dizer da função do IDE, presente em todos os códigos, e que promove a repetição indefinida da parte de código alí escrita.
72
String ler; //string é um vetor de caracteres lido integralmente
boolean flag = false; //cria um booleano atribuindo valor inicial "falso"
int led = 13;
void setup() {
pinMode(led, OUTPUT);
Serial.begin(9600); //inicia comunicaçao serial estabelecendo taxa de transmissão
//de dados
}
void loop() {
if(Serial.available()>0){ //verifica dado serial disponivel para leitura
ler = Serial.readString(); //havendo dado, o mesmo eh armazenado na variável "ler"
}
if(ler == "ligar"){ //se ligar for o valor da variável...
flag = true; //o booleano recebe valor verdadeiro
}
if(flag == true){ //sendo o booleano verdadeiro, led piscará
digitalWrite(13,HIGH);
delay(500);
digitalWrite(13,LOW);
delay(500);
}
if(ler=="desligar"){ //se a variavel tem valor "desligar"...
flag = false; //booelado eh falso e, consequentemente, LED para de piscar
}
}
Por comodidade, foi utilizado o pino 13 que, como já vimos, está conectado a um LED da
própria placa. Ao clicar no ícone do monitor serial (ultimo ícone da Fig. 3.26) teremos uma nova
janela com um campo para receber informações do teclado e fazer o envio para placa, e outro
para visualização dos dados que estão sendo enviados pelo Arduino.
A Fig. 3.58 ilustra o falado apontando os campos descritos e o seletor de taxa de
comunicação, necessário para que as mensagens sejam repassadas e lidas corretamente.
73
1 2
Figura 3.58. Serial monitor. Nele, podemos observar um campo para escrita (1) que será repassado
ao microcontrolador serialmente, ao pressionar a tecla Enter do teclado ou o botão "Enviar" (2).
Devemos ajustar a velocidade de comunicação (3) de acordo com a utilizada no código para que
as respostas, caso haja alguma, possam ser mostradas corretamente na tela (4).
Como não foi solicitado que os dados mandados pela placa fossem mostrados, nada
aparecerá e, por consequência, saberemos que um dado enviado para a placa foi devidamente
recebido através da mudança de estado do LED dessa placa.
O envio do texto “ligar” implica na mudança do valor da variável flag. Tal variável foi criada
para ser utilizada como auxiliar no código, de forma que sua mudança de valor sinalizasse
quando o LED deveria começar a piscar, entrando no if-loop e quando deveria parar, ao não ter
acesso a ele por não satisfazer a condição de entrada na estrutura do “if”.
A solicitação de um comando por parte do usuário do programa para que uma ação seja
realizada é de grande importância em projetos de controle nos quais o sistema deve atender a
solicitações de quem o utiliza, por exemplo.
Além disso, certas aplicações precisam ser verificáveis de que ocorreram para maior
segurança do sistema. Assim, introduzir mensagens para checar etapas pode e deve ser usado
nessas circunstancias.
Experimente utilizar a função serial.print() ou serial.println() dentro das estruturas

condicionais (if) do código anterior para expressar alguma confirmação como, por exemplo,
74
Serial.println(“Comando para piscar em funcionamento!”);
dentro da condicional que verifica se o comando “ligar” foi dado.

Caso tudo funcione corretamente, o monitor serial começará a exibir a a frase como
mostrado abaixo.
Figura 3.59. Serial monitor referente ao código com acrescimo de resposta. Após inserir o
comando, a mensagem "Comando para piscar em funcionamento!" aparecerá toda vez que for
verificado o valor armazenado na variável flag como sendo "ligar".
75
A partir do que já foi apresentado até o momento, temos agora uma autonomia maior para
o desenvolvimento de alguns outros projetos.
76
4. APP INVENTOR: Programação mobile
O App Inventor possibilita o desenvolvimento de aplicativos de forma simples utilizando-

se de uma linguagem com paradigma puzzle, ou seja, soluções baseadas na montagem de um
quebra-cabeça. Assim, o desenvolvimento das aplicações necessita, basicamente, que o usuário
arraste as estruturas de suas fontes para a tela de desenvolvimento para que sejam encaixadas
(“drag and drop”), tornando a programação simples e intuitiva.
É uma ferramenta em nuvem, desenvolvida pela Google e mantida pelo MIT, que permite
a construção no próprio navegador de internet e, assim, certa comodidade no que diz respeito
ao armazenamento do que é desenvolvido e na transferência para dispositivos móveis com
tecnologia Android, onde podem ser executados. No capítulo anterior foram passadas algumas
informações básicas e importantes para a programação em Arduino, mas as mesmas podem ser
aplicadas, mesmo que apenas o que diz respeito a ideia, sua lógica, em outros ambientes de
programação.
Para aqueles que não estão familiarizados com nenhuma linguagem ou forma de
programação é sugerido que, anteriormente a sequência nos estudos do que aqui será
apresentado, acessem ao site da CODE e realizem algum dos exemplos oferecidos de “HORA
do CÓDIGO” (https://code.org/learn), para adquirir uma noção mínima acerca da programação
em blocos.
Feito isso, podemos iniciar de uma maneira mais cômoda as questões que envolvem o
APP Inventor.
4.1. Por que utilizar o App Inventor?
Como já dito, a programação por blocos facilita o desenvolvimento uma vez que é mais
intuitiva que os modelos mais convencionais (tal como o utilizado para o Arduino). Outro
argumento significativo é a facilidade de desenvolvimento e testes em tempo real sem a
necessidade de instalação de uma IDE.
O processo de desenvolvimento e construção do aplicativo ocorre todo em nuvem e isso
torna sua execução prática, pois a aplicação funciona de modo inteiramente online, diretamente
do navegador e, para utilizar da plataforma, basta possuir uma conta de usuário Google.
Na educação, a utilização desse modelo de programação vem ganhando força.
Programadores e celebridades como Bill Gates (Microsoft) e Mark Zuckerberg (Facebook) se
77
juntaram à organização Code.org para incentivar crianças e jovens a aprender programação. A
Code.org é uma organização sem fins lucrativos que visa aumentar o ensino de programação de
computadores em escolas e direcionar pessoas através de ferramentas online.
4.2. Acessando
Para ter acesso5 à plataforma é necessário, inicialmente, que se tenha uma conta Google.
Assim, acesse a página http://appinventor.mit.edu/explore/ e clique em “Create app!”, botão
localizado na parte superior direita do site (ver Fig. 4.1).
Figura 4.1. Parte superior do site, onde devemos clicar no botão superior direito (laranja).
Ao clicar no botão, a ação irá redireciona-lo para uma página com solicitação de login
semelhante à da figura abaixo. Nela, realize os procedimentos necessários, seja para a criação
de nova conta (aqui, deve-se clicar em “Criar conta”) ou para acesso de uma já existente.
Após informar dados de login e senha pela primeira vez, seu dado de login ficará gravado,
facilitando acessos posteriores.
5 Para acesso e uso da plataforma devemos utilizar os navegadores Chrome ou Mozila Firefox.
78
Figura 4.2. Campo para realizar login na conta Google. Caso não possua conta, é necessário ir em
“Criar conta” primeiramente.
Figura 4.3. Tela de login com uma conta já salva para acesso.
79
Por fim, no primeiro acesso, serão apresentados os termos de serviço para uso do App
Inventor. Estando de acordo com os termos de serviço, clique em “I accept the terms of service!”
e poderemos prosseguir para o contato inicial e desenvolvimento de aplicativos.
Figura 4.4. Termos de Serviço para uso do App Inventor.
4.3. Contato inicial
Agora entraremos de fato no ambiente de desenvolvimento! Como se trata do primeiro

acesso, ainda serão verificadas duas janelas de boas-vindas: uma solicitando o preenchimento
de um questionário, o qual poderá ser respondido de imediato, mais tarde ou nunca (botões com
essas respectivas alternativas); a outra janela de boas-vindas traz informações sobre a versão
atual da plataforma dentre outas questões. Após clicar em “continue”, teremos a tela de criação
do primeiro projeto e, nos próximos acessos, a página trará uma lista dos projetos já elaborados.
A janela de boas-vindas com informes da última versão será apresentada todas as vezes
que iniciarmos acesso à plataforma. Já em sua primeira aparição ou em qualquer outra podemos
marcar a caixa de opção “Do not Show Again” (não mostrar novamente).
80
1 2 3
Figura 4.5. Janela solicitando o preenchimento de questionário. Podemos responder o questionário

de imediato (1), mais tarde (2) ou nunca (3).
Figura 4.6. Tela de boas-vindas. Ao clicar no botão “Continue” (canto inferior esquerdo). Partiremos
para uma tela de criação de projetos.
4.4. Novo projeto: duas visões
A página na qual seremos direcionados, no primeiro acesso, apresentará uma mensagem

informativa indicando o uso do “Guide” ou, para já criarmos um novo projeto, a opção de
selecionar “Start new project” (iniciar novo projeto).
Quando iniciamos um novo projeto, devemos, primeiramente, nomeá-lo. Teremos, por
fim, acesso a todos os elementos de construção do projeto desejado.
81
Outra forma de iniciar um novo projeto é selecionar a opção dentro do menu “Projects”,
conforme será apresentado num outro momento mais adiante.
Figura 4.7. Mensagem apresentada quando nenhum projeto ainda foi criado com informações de
sugestões a serem seguidas inicialmente.
Figura 4.8. Tela ao realizar primeiro acesso. Ao clicar em “Start new project” e dar um nome ao
novo projeto, a página será redirecionada para a edição do mesmo.
Figura 4.9. Janela que será mostrada para dar nome ao projeto que será criado.
A ferramenta é dividida em duas partes principais: Designer e Blocks.

Na primeira parte, será desenvolvida a interface do aplicativo para dispositivo Android,
conforme apresentado na Fig. 4.10. Nela, é possível fazer a adição dos componentes com o qual
82
o usuário irá interagir, estabelecer a criação de banco de dados, tipo de conexão de rede a ser
utilizada, dentre outros componentes disponíveis. Além de também ser possível realizar upload
de arquivos e todo o tratamento do que será apresentado ao usuário final do aplicativo
desenvolvido.
Já em Blocks, apresentado na Fig. 4.11, será construída a programação do aplicativo.
O App Inventor utiliza uma programação em blocos, sendo assim, as estruturas serão arrastadas
da sua fonte de origem, na aba Blocks, e soltas na área de construção do código, o Viewer, e
encaixadas umas às outras, gerando blocos maiores os quais conterão a formulação lógica e
sintática do programa.
Figura 4.10. Visão Designer
Figura 4.11. Visão Blocks
83
Podemos realizar os mais diversos procedimentos conforme citado ao início do capítulo.
Dessa forma, iremos cobrir os diversos painéis pertinentes ao Designer a ao Blocks.
Elementos relativos ao salvamento do projeto, seu build, dentre outros, também serão
apresentados, porém, nem todos os elementos da plataforma serão abordados por fugirem do
escopo de maior interesse aqui proposto. Para tanto, sendo de interesse pessoal, é possível,
através do próprio site, explorar as mais diversas possibilidades e tutoriais para desenvolvimento
em outras áreas.
4.5. Designer
Conforme apresentada, é a área onde será montada a interface do aplicativo. Todas as

funcionalidades, visões de tela, componentes selecionados etc, serão manipuladas nessa aba
da página e estarão ali dispostas para seu desenvolvimento visual.
VIEWER
Os components que forem selecionados do Palette devem ser arrastados até a tela do
Viewer. Tal tela, semelhante a de um smartphone seria a representação de como o aplicativo
seria visualizado pelo usuário. Sendo assim, qualquer alteração de forma, posição, adição de
tela, acréscimo de informação realizados serão ali representados para que o desenvolvedor
tenha ciência de como tudo o que foi incorporado será visto assim que tudo for finalizado.
No Viewer também podemos tornar visíveis componentes selecionados como invisíveis
para ter noção de sua localização na tela como, por exemplo, uma caixa de texto que irá mostrar
informações de resposta a alguma ação na tela, mas que o usuário final não precisa
necessariamente saber sua localização ou clicar nela para digitação. Essa alteração é realizada
ao clicar na caixa de seleção na parte superior à tela do aplicativo em desenvolvimento, onde é
possível também selecionar uma visualização prévia de como o app ficaria na tela de um tablet.
Por fim, alguns componentes ao serem arrastados para a tela do aplicativo são lançados
automaticamente para uma posição abaixo da tela em “Non-visible components” (componentes
não visíveis). Esse caso em específico ocorre para componentes que representam elementos
que são utilizados pelo aplicativo de forma mais implícita ou interna. A exemplo disso temos a
conectividade com a rede wireless e o acelerômetro, elementos frequentemente utilizados,
porém, que não são manipulados diretamente pelo usuário ou necessários de serem monitorados
pelo mesmo explicitamente na tela do aplicativo.
84
Figura 4.12. Viewer, onde podemos vizualizar o aplicativo em desenvolvimento.
PALETTE
Conforme já citado previamente, é daqui que os componentes são arrastados para a tela
(viewer) do que, futuramente, será um aplicativo. Existe uma grande variedade de componentes,
os quais são divididos em grupos de acordo com uma característica comum e, conforme pode
ser visto na próxima figura, possuem um ícone de interrogação à direita o qual contém
informações gerais de sua funcionalidade.
Caso uma especificação mais detalhada seja desejada ou necessária, basta que o
usuário clique em “More information” (mais informações). Uma nova página será aberta e uma
informação completa sobre o elemento será repassada.
85
Figura 4.13. Palette com exemplo das interrogações ao lado dos componentes. Ao clicar, temos
informação do componente e a opção para mais informações (“More information”), que nos leva a
uma nova página com detalhes sobre o componente.
COMPONENTS E SCREENS
Feita a seleção de um elemento no Palette, arrastando-o para o Viewer, ele agora estará
disponível no painel de Components.
Quando damos início a um novo projeto é possível visualizar nessa área o componente
“Screen 1”, que nada mais é que a tela do aplicativo que será exibida ao usuário num dado
momento, e todos os demais componentes estarão em um nível interno ao mesmo.
Caso uma nova tela seja criada, em “Add Screen ...”, o que pode ser feito na parte superior
ao painel (ver Fig. 4.14), os componentes da tela anterior não estarão representados ali. Ou seja,
cada tela em Design mostrará apenas os componentes nela colocados.
Diferente da primeira tela, as demais podem receber um nome diferente do já proposto
pela plataforma e para alternar entre essas telas basta que cliquemos no botão à esquerda de
“Add Screen ...” e selecionarmos a desejada da lista.
Uma Screen adicionada também pode ser removida através de “Remove Screen”.
86
Figura 4.14. A clicarmos em "Add Screen" podemos dar um nome a nova tela como, por exemplo
"TelaTeste".
Figura 4.15. A nova tela, quando selecionada, apresenta apenas seus próprios componentes. Note
que "Screen1" não está representada em Components e que "Remove Screen" foi habilitado.
Ao final do painel existem dois botões: “Rename” e “Delete” para que os nomes dos
componentes possam ser alterados ou para que o componente possa ser deletado e sair da tela
de visão do projeto. Uma janela com um campo mostrando o nome antigo e um campo para que
o novo seja escolhido aparecerá ou uma confirmação de deleção, caso escolha excluir o
componente.
Figura 4.16. Components, onde os elementos selecionados do Palette para o Viewer são listados.
87
Figura 4.17. À esquerda a janela de renomear componentes e à direita, para deletá-lo.
PROPERTIES
Todos os elementos possuem propriedades atribuídas e que podem ser modificadas para
melhor se adequar ao pretendido pelo desenvolvedor no design de seu aplicativo. Assim, ao
selecionar um elemento em Components, é possível editar uma serie de suas características
para que ele melhor se adeque ao desejado.
Num botão, por exemplo, podemos alterar sua cor, forma, tamanho, texto em seu interior,
alinhamento da estrutura na tela, dentre outros.
Como cada componente possui suas propriedades específicas e o design é algo pessoal,
fica a critério do desenvolvedor verificar o que é desejável de se utilizar ou não. Futuramente,
em exemplos, algumas dessas funções serão demonstradas e fugiria ao pretendido através
desse material uma explicação detalhada de todas os campos de propriedade, bem como
também não foram detalhados a fundo os elementos do Palette.
88
Figura 4.18. Lista com algumas das propriedades de “Screen1” listados em Components.
MEDIA
Tanto DESIGNER quanto BLOCKS tem um campo destinado para o upload de arquivos.
Os arquivos subidos, sejam de áudio, imagem ou vídeo, podem ser empregados para finalidades
diversas. Podemos utilizar um alerta sonoro ou visual para avisar que uma ação deve ou não ser
tomada, um áudio que seja resposta a uma ação (emissão de som quando clicado na tela, por
exemplo) indo da necessidade do desenvolvedor em como utilizar dessa função.
Feito o upload do arquivo, seu uso se dá através das propriedades do elemento que pode
utilizado, sendo o mesmo selecionado em Properties.
Figura 4.19. Painel Media, por onde é possível realizar upload de imagens, áudios e vídeos.
89
4.6. Blocks
Conforme também apresentado, essa aba é a responsável pelos bastidores do show.

Aqui se encontram os blocos para o desenvolvimento lógico da programação por trás de
cada um dos elementos dispostos na tela do aplicativo que exijam dar e/ou receber comandos.
Os blocos seriam uma abstração maior de um código em javascript por trás de cada encaixe e
proporciona facilidades no desenvolvimento de aplicativos por, por exemplo, não permitir que
peças que não tenham sentido em serem postas juntas (parâmetros cuja lógica de programação
não seja compatível) se encaixem. Além disso, apresentam elementos gerais de construção e
aqueles específicos dos componentes selecionados pelo desenvolvedor para seu aplicativo.
BLOCKS
Nesse painel são encontrados os blocos de construções gerais: os “built-in”, divididos em

grupos. Cada grupo possui uma cor específica que o identifica.
Abaixo desses blocos é possível verificar os componentes do projeto com estruturas
particulares de construção para cada um. Quando seu aplicativo estiver sendo elaborado,
estarão dentro de “Screen1”, caso seu aplicativo possua apenas uma tela, e, caso tenha múltiplas
telas, dentro de cada uma delas. Além disso, em “any component”, existem blocos relacionados
ao tipo de componente utilizado no projeto ao invés de em um componente específico (blocos
são para qualquer botão ao invés de para o “button1”, por exemplo).
Por fim, o painel também oferece a opção de alterar o nome dos componentes inseridos
no projeto (como no painel “components”).
Figura 4.20. Painel dos blocos de construção da programação por trás do aplicativo
90
VIEWER
Conforme no DESIGNER, nesse painel serão arrastados os blocos que correspondem as

peças do quebra-cabeça a ser montado, representando a programação por trás da tela do
aplicativo.
Alertas sobre algum problema na programação são mostrados no canto inferior esquerdo,
sendo a quantidade de erros sinalizadas pelos números ao lado dos símbolos e sua localização
mostrada no Viewer, ao clicar em “Show Warnings”.
No canto superior direito existe uma backpack na qual podem ser guardados os blocos
favoritos de programação utilizados, evitando delongas em sua pesquisa no painel Blocks. Caso
não deseje mais algum bloco ali colocado, é necessário segurar o botão direito do mouse para
que seja exibida a lista de opções do que pode ser feito com a backpack.
No canto inferior direito estão as ferramentas de posicionamento da tela de projeto
centralize, zoom in, zoom out e a lixeira (ou botão delete de seu computador) para que blocos
não utilizados sejam deletados.
Figura 4.21. Painel onde são colocados os blocos de programação.
91
Figura 4.22. Alertas de erros. Ao clicar em "Show Warnings" os erros serão discriminados em tela
e, ao clicar nos simbolos, informações serão apresentadas.
4.7. Elaborando projetos
Independentemente da aba ou área que estiver utilizando sempre será possível verificar na
parte superior da página a logo do App Inventor e, na mesma faixa vertical, um menu com listas
de opções importantes para acesso, construção, teste e finalização dos projetos.
Figura 4.23. Visão parcial do menu.
Em Projects é possível acessar os projetos elaborados, iniciar um novo, importar, exportar

e salvá-los. A extensão “.aia” representa uma aplicação App Inventor elaborada e salva-la pode
ser útil para compartilhamento direto com outras pessoas, por exemplo, caso desejemos passar
o projeto elaborado para alguém.
Como dito anteriormente e mostrado na figura abaixo, através desse menu é possível
iniciar um novo projeto, porém, quando estamos na página My Projects, que é um dos menus da
barra e, também, o primeiro item da lista em Projects, verificamos logo acima da lista de projetos
criados um botão de “Start new project ” (verificar Fig. 4.8). Independentemente de onde
92
estivermos e clicarmos, essa opção nos direcionará para uma página limpa de montagem de
projeto na visão do Designer.
Figura 4.24. Aba Projects do menu.
Em Connect podemos realizar o pareamento do dispositivo android para que possamos,

em tempo real, visualizar o desenvolvimento do projeto, se seus componentes estão funcionando
como esperado e estão na forma e posição desejada. Aqui, existem três opções de conexões
sendo aconselhada para uso a “AI Companion” a qual, através da leitura de um QR Code, realiza
o pareamento. Além disso, é possível resetar as conexões existentes nesse menu.
As demais opções, são recomendadas em casos onde a conexão com uma rede por parte
do smartphone seja completamente inviável ou caso não tenhamos acesso a um dispositivo
desses. Para nos poupar dessa questão, que é um pouco maçante, acesse a página:
http://appinventor.mit.edu/explore/ai2/setup, caso seja necessário.
Figura 4.25. Aba Connect do menu.
É importante frisar que o “AI Companion” exige que os dispositivos conectados, tanto o
computador quando o smartphone Android, estejam na mesma rede. Caso isso não seja
93
obedecido um erro ao tentar a conexão em tempo real será apresentado na tela e essa conexão
não será estabelecida.
Além disso, devido ao fato de algumas redes sem fio serem configuradas de modo a
proibir dois dispositivos dessa rede de se comunicaram (como redes de escolas e universidades),
o uso do “AI Companion” pode ser dificultado, mas ainda consiste numa melhor opção que o
“Emulator” ou o “USB”. Sendo assim, para que o pareamento seja feito seguiremos alguns
passos simples:
1. Conectar o smartphone à rede sem fio da instituição de ensino;
2. Conectar o smartphone ao computador via cabo USB;
3. Nas configurações do aparelho, buscar pelas opções de conexões do mesmo e
um menu que aborde “Ancoragem e Roteador Wi-Fi” ou similar para realizarmos
a ancoragem do mesmo via USB;
4. Selecionar a opção “Ancoragem via USB” ou similar;
5. Com o computador desconectado de qualquer rede, aguarde o reconhecimento
de uma nova rede à cabo e que sua conexão seja realizada (o processo pode
demandar algum tempo).
Feito isso, a conexão com a internet do Android estará sendo compartilhada com o
computador estando, dessa forma, os dois dispositivos numa única rede (como se fossem um
mesmo equipamento, digamos assim) possibilitando que o “AI Companion” funcione
normalmente.
Figura 4.26. Captura de tela da lista de ancoragem em Galaxy J5 Pro. No canto superior esquerdo,
na barra de notificações, um ícone com o símbolo de dispositivo USB é apresentado após a seleção
da opção via USB, sinalizando que a ancoragem está sendo feita.
Quando vamos para a Build estamos no momento final da construção do projeto. Aqui, o
aplicativo será compilado e preparado para que a extensão de aplicativo “.apk” seja criada. É
possível gerar um QR Code para a extensão, transferindo-a diretamente para o smartphone ou
salva-la no computador, para que seja enviado posteriormente para o smartphone.
94
Figura 4.27. Aba Build do menu.
As demais opções também sinalizam sua funcionalidade, e podem ser verificados pelo
desenvolvedor a qualquer momento, caso tenha interesse em aprender algo diferente ou mais a
fundo, para verificar aplicativos desenvolvidos por outras pessoas na galeria, verificar guias,
idioma6 (inglês por padrão) etc.
Visto tudo isso até o momento, um projeto a ser elaborado segue os seguintes passos:
1. Início do projeto ao selecionar “start new project” em “Projects”;
2. Elaboração do projeto, no que diz respeito ao seu design e programação e,
enquanto ele está sendo elaborado, é aconselhável o pareamento com um
smartphone para que possa ser verificado em tempo real o que está sendo
realizado (utilizando a mesma rede na qual o computador para edição do projeto
estiver).
3. Seleção de opção e realização de build para que o aplicativo possa ser compilado,
preparado e montado para a instalação no dispositivo Android ou download no
computador.
4. Instalação propriamente dita. Ela pode ocorrer diretamente após a build quando
do uso da transferência direta via QR code ou após sua transferência do
computador para o dispositivo Android, ao selecionar o arquivo do programa e
solicitar sua instalação.
Os smartphones são configurados para que apenas aplicativos advindos de uma loja
virtual registrada como confiável sejam instalados. Dessa forma, ao tentar instalar uma aplicação
de fonte desconhecida, um alerta semelhando ao da imagem abaixo será apresentado. É
necessário, então, ir até as configurações do smartphone para conceder essa permissão (que
pode ser dada apenas para a instalação em questão ou para todas as demais). A opção é
encontrada, normalmente, nas opções de segurança das configurações dos dispositivos.
6 Todos os termos utilizados correspondem aos termos em inglês e não aos em português brasileiro, pois a troca do idioma é aplicada
apenas enquanto a sessão está ativa na plataforma. Ao atualizar, logar novamente ou ser reconectado a pagina voltará ao idioma
de origem. Dessa forma, para evitar alguns equívocos ou confusão durante a elaboração dos projetos esse material utilizará os
termos no idioma padrões da plataforma.
95
Terminado todos esses procedimentos o aplicativo estará, finalmente, pronto para uso.
Figura 4.28. Do lado esquerdo, a primeira mensagem de segurança gerada ao tentar instalar o
aplicativo. Do lado direito, uma mensagem que é gerada após o gerenciamento das configurações
para que seja permitida a instalação do aplicativo (imagens referentes aos alertas do smartphone
Samsung Galaxy J5 Pro).
4.8. MIT AI2 Companion
Para que seja possível o acompanhamento em tempo real do projeto em desenvolvimento

e também sua fácil e rápida transmissão para um smartphone Android é necessário a instalação
do Mit AI2 Companion no dispositivo.
A partir desse aplicativo é possível realizar a leitura do QR Code gerado, tanto para a
conexão entre a plataforma e o smartphone, quanto para a transferência e instalação do
aplicativo. Caso a leitura do QR Code não funcione, também é possível inserir um código de seis
caracteres, permitindo a conexão.
96
Figura 4.29. Tela do aplicativo de conexão com a plataforma do App Inventor.
O mesmo pode ser baixado e instalado através da Play Store, pesquisando-o pelo seu
nome.
4.9. Criando um aplicativo
Sabemos agora os passos para o desenvolvimento de um aplicativo e temos uma breve

noção do que a plataforma pode nos oferecer no que diz respeito a variedade de componentes
para realizar um projeto. Sendo assim, podemos dar início a algumas construções simples.
A programação com paradigma puzzle facilita ao desenvolvedor o entendimento das
estruturas por trás do design. Os exemplos a seguir irão explorar um básico sob essa lógica de
programação, importante para os projetos futuros que irão incluir o uso de um microcontrolador
juntamente ao App Inventor.
De início será apresentada uma tabela resumindo os componentes selecionado e os
parâmetros que foram alterados (caso haja algum) em Properties e, em seguida, um
detalhamento textual da montagem, configuração e programação será repassado juntamente
com as figuras que ilustram os projetos em suas abas Designer e Blocks.
Para facilitar o entendimento inicial das tabelas, figuras ilustrarão o processo nos
exemplos iniciais. Vale lembrar também, que as alterações referentes a cor, tamanho da fonte,
posicionamento dos elementos, dentre outros, são apenas sugestões e recomendações para
97
facilitar o entendimento dos aplicativos e torna-los visualmente simples. Caso seja de interesse,
o leitor pode realizar suas próprias configurações nesses elementos não críticos à execução do
aplicativo. Fique à vontade para imaginar!
“HELLO, WORLD!” AO CLICK DE UM BOTÃO

Aqui, faremos com que, ao clicar num botão, seja realizada uma reprodução sonora da
frase “Hello, World!”
Ao realizar seu acesso na plataforma do MIT App Inventor vá em Projects e selecione
Start new project e de um nome ao mesmo, como “Hello_World”.
Figura 4.30. Menu de acesso para iniciar novo projeto.
Figura 4.31. Dando nome ao novo projeto.
98
A tabela seguinte mostra os componentes que serão usados e as alterações a serem
feitas em cada elemento de algumas de suas propriedades. Em seguida, um detalhamento sobre
essas alterações será mostrado para facilitar a compreensão da tabela.
Tabela 4.1. Componentes do projeto "Hello, World!" e seus atributos modificados.

Components Onde encontrar Properties Valor
BackgroundColor orange
Button1 User Interface FontSize 20
Text Aperte o botão!
Country USA
TextToSpeach1 Media
Language en
No painel Palette, selecione um botão (“Button”) na aba “User Interface” e arraste-o para
a tela. Em seguida, selecione o botão em Components, pois faremos algumas alterações no
painel Properties.
Figura 4.32. Arrastando um botão para a tela do aplicativo.
Podemos, por exemplo, alterar a “BackGroundColor” para “Orange”, “FontSize” para “20”
e “Text” para “Aperte o botão!”.
99
Figura 4.33. Alterando as propriedades do botão (ver setas vermelhas) e como as alterações
aparecem em "Viewer".
Como queremos que a frase seja reproduzida ao clicarmos, faremos uso do componente
“TextToSpeach”, encontrado na aba “Media” do Palette. Conforme citado anteriormente, alguns
componentes são postos como não visíveis (“non-visible”) durante a construção do projeto,
sendo esse um caso dessa ocorrência.
100
Figura 4.34. Componente "TextToSpeech" é arrastado normalmente para a tela, mas é posicionado
como um componente não visível, abaixo da tela do aplicativo, como marcaodo na figura.
É interessante, nas configurações desse elemento não visível, selecionar em “Country” a

opção “USA” e “en”, em “Language”, tendo em vista que a frase a ser dita está em inglês.
Figura 4.35. Alteração nas propriedades do componente "TextToSpeech1".
101
As alterações realizadas no botão todas, de alguma forma, para atender o design
esteticamente e facilitar o entendimento do que devemos fazer no aplicativo pronto. Em
contrapartida, as mudanças realizadas no segundo componente já têm uma finalidade que
envolve os recursos a serem usados quando o programa por trás da tela do aplicativo for rodado.
Por isso, ao fazer alterações por conta própria em Design, atente-se a quais delas afetaram
somente a estética.
Iremos agora sair da aba Designer para montar a programação em Blocks.
No painel Blocks, iremos selecionar “Button1”, que é referente ao botão criado na aba
Designer. Uma aba será aberta com os blocos de programação pertinentes ao botão, conforme
mostra a figura abaixo, e onde iremos selecionar e arrastar para o viewer a primeira estrutura:
“when Button1.Click do”.
Figura 4.36. Estruturas de construção referentes ao Button1. A estrutura relacionada com a seta
deve ser posta na tela do Viewer para iniciarmos nossa programação.
Esse bloco é uma estrutura condicional na qual, quando (“when”) o botão for clicado, uma
ação será realizada (“do”). Aqui, queremos que uma frase seja reproduzida quando a ação de
clicar no botão for realizada e, sendo assim, devemos selecionar “TextToSpeach1”, o bloco “call
TextToSpeach1.Speak message”, encaixando-o no bloco anterior.
102
Figura 4.37. Bloco de interesse a ser arrastado para a tela de montagem do programa.
Figura 4.38. Os dois blocos devem ser, então, conectados.
Figura 4.39. Blocos devidamente encaixados.
Por fim, é necessário selecionar qual será a mensagem que será dita e fazer sua conexão
na saída do bloco. Selecionamos “Text” em “Built-in”, onde blocos relacionados a textos e
caracteres estão agrupados, e arrastamos o primeiro bloco (vazio entre aspas). Nele, iremos
clicar no espaço vazio e digitar “Hello, World!”.
103
Figura 4.40. Bloco para inserção de texto a ser arrastado para a área de programação.
Figura 4.41. Bloco de texto devidamente encaixado aos demais.
Figura 4.42. Digitando o texto de interesse.
Ao final da escrita do texto podemos pressionar a tecla de return (“enter”) ou clicar numa
parte vazia do Viewer. Os blocos do programa ficarão como abaixo apresentado.
Figura 4.43. Programação em blocos do aplicativo finalizada.
104
É importante lembrar que podemos realizar o pareamento de um smartphone e visualizar
no dispositivo cada passo que foi realizado e se o programa está funcionado. Após finalizado
todos os ajustes, realizaremos a Build do programa.
Figura 4.44. Menu de Build para seleção.
A build, caso seja selecionada a primeira opção do menu como na Fig. 4.44, gerará um
QR code o qual, através do MIT AI2 Companion, deve ser scaneado para que a instalação do
aplicativo ocorra.
Figura 4.45. QR Code gerado ao finalizar a build do projeto.
105
Finalizada a instalação, basta procurar o ícone e nome do projeto no menu de aplicativos
do dispositivo móvel e seleciona-lo para que seja feito o teste.
Figura 4.46. Ícone gerado automáticamente. Após a instalação do aplicativo elaborado, devemos
buscar pelo ícone com o nome que demos ao aplicativo.
TRANSFORMAR QUALQUER TEXTO EM FALA

Indo além do apresentado da reprodução de uma frase específica, como mostrado no
projeto anterior, podemos também solicitar a reprodução de qualquer texto que o usuário deseje.
Para realizar essa ação, podemos utilizar o projeto anterior como base e realizar algumas
pequenas modificações nas duas abas do projeto. Lembre-se de usar a ferramenta de conexão
“AI Companion”, para analisar em tempo real o que está sendo produzido.
Tabela 4.2. Componentes do projeto para transformar qualquer texto em fala e seus atributos
modificados.
BackgroundColor orange
Button1 User Interface FontSize 20
Text Falar!
TextBox1 User Interface Hint Digite algo
Country USA
TextToSpeach1 Media
Language en
No Designer, criado um novo projeto, acrescente os mesmos componentes do aplicativo

anterior alterando o “text” do botão para “Falar!” (ou outro texto de interesse).
106
Figura 4.47. Dando o nome de "Qualquer_texto" ao novo app a ser desenvolvido.
Figura 4.48. Nova configuração do botão com propriedades modificadas indicadas pelas setas
vermelhas.
Em seguida, acrescente um novo componente: o “TextBox” (também em “User Interface”),

abaixo do botão, alterando seu “Hint” para “Digite algo” (ou outro texto de interesse). Esse texto
será exibido ao iniciar o aplicativo, em cor mais clara, desaparecendo ao clicar no campo.
107
Figura 4.49. Arrastada e soltada, abaixo do botão, temos um campo de texto ("TextBox").
Figura 4.50. Campo alterado em "TextBox1" para que uma dica apareça ao usuário do que fazer
naquele campo.
Por fim, acrescentamos o componente “TextToSpeech” e o configure conforme no

aplicativo anterior (tendo em vista que, infelizmente, não temos uma configuração para português
brasileiro).
108
Figura 4.51. Inserindo o componente que transforma texto em voz.
Figura 4.52. Configurações do componente que transforma texto em voz.
Em Blocks, a programação é semelhante sendo alterado apenas a última peça na qual,

ao invés de um bloco para texto, iremos selecionar o elemento de construção “TextBox1.text”
dos blocos específicos do componente “TextBox1”. Veja as imagens a seguir ilustrando o novo
programa.
109
Figura 4.53. Aba Designer com o novo componente selecionado.
Figura 4.54. Componente a ser arrastado para o Viewer.
Figura 4.55. Aba Blocks, com a nova programação em blocos elaborada.
110
Faça agora o Build e veja o resultado! Digite uma frase no campo de texto e aperte o
botão.
ALTERNAR IMAGENS EM TELAS DIFERENTES CLICANDO NUM BOTÃO
Como mencionado, podemos criar novas telas e trocar entre os dois ambientes, tendo,
cada uma, seus componentes específicos.
Para o novo aplicativo, faremos uso de um botão que nos levará para uma outra tela.
Cada tela também terá um botão e uma imagem específica de uma lâmpada, simulando seu
acionamento e desligamento.
Ao iniciar um novo projeto (nomeado twoScreensLamp) iremos, primeiramente, no painel
Media e realizaremos o upload de duas imagens (a sua escolha) sinalizando uma lâmpada
apagada e uma acesa como as representadas na figura abaixo.
Figura 4.56.Imagens de uma lâmpada acesa e apagada, as quais serão enviadas para a plataforma
(upload) para serem utilizadas no projeto.
Para fazer isso, clicaremos em “Upload File ...” e, na janela que for aberta, em “Escolher
arquivo”. Selecione o primeiro arquivo de interesse após localiza-lo em seu computador, clique
em “Abrir” e, feito isso, clique em “OK” na janela de “Upload File ...” que foi aberta. Repita o
processo com a próxima imagem.
111
Figura 4.57. Janela aberta ao clicar em "Upload File ...". Devesse escolher o arquivo desejado em
“Escolher arquivo” e clicar em “OK” após seleção.
Figura 4.58. Janela após a seleção de um arquivo de imagem. Devemos, aqui, clicar em “OK” para
finalizar o carregamento do arquivo.
Figura 4.59. Exemplo de janela para procurar e selecionar os arquivos de imagem. No canto inferior
direito temos as imagens, já carregadas, no painel “Media”.
Conforme a Fig. 4.59 mostra, os nomes dados aos arquivos foram “lampc.jpg” e
“lampo.jpg”, e eles representam a lâmpada desligada e ligada, respectivamente.
112
Na tabela a seguir são mostrados os componentes utilizados e as propriedades alteradas.
Observe que a mudança de telas faz com que os componentes no painel “Components” reiniciem
suas numerações.
A nova tela criada tem o nome “apagarLuz” e para acessa-la após a criação, devemos
acessar o menu de telas.
Figura 4.60. Criando uma nova tela denominada "apagarLuz".
Figura 4.61. Nova tela "apagarLuz", após sua criação.
113
Tabela 3. Componente do projeto de alternar imagens em telas diferentes e seus atributos
modificadas.
Components
Onde encontrar Properties Valor
(Screen1)
BackgroundColor Yellow
FontSize 20
Button1 User Interface Width Fill parente
Shape Rounded
Text Toque aqui para ligar
Height Fill parente
Width Fill parente
Image1 User Interface
Picture lampc.jpg*
ScalePictureToFit Marcar
Components
Onde encontrar Properties Valor
(apagarLuz)
BackgroundColor Red
FontSize 20
Button1 User Interface Width Fill parente
Shape Rounded
Text Toque aqui para desligar
Height Fill parente
Width Fill parente
Image1 User Interface
Picture lampc.jpg*
* upload de imagens de lâmpada apagada e acesa são feitos no painel Media.
Ao final do desing, as telas terão a seguinte configuração (seguindo a tabela):
114
Figura 4.62. Imagens das telas projetadas para o aplicativo que alterna imagens em duas telas.
Para a programação em Blocks começaremos por Screen1 adicionando uma ação ao

botão para que uma nova janela seja aberta quando o mesmo for clicado. Isso exige o uso de
um Built-in localizado em “Control” chamado “open another screen screenName”.
Figura 4.63. Localização do bloco necessário para mudança de tela.
115
Como podem ter percebido, o bloco exige um encaixe. Devemos passar para o mesmo a
informação de qual nova tela será aberta e faremos isso a partir de um bloco de texto simples.
Veja a próxima figura.
Figura 4.64. Bloco finalizado para mudar de "Screen1" para "apagarLuz".
Nosso primeiro pensamento seria o de prosseguir da mesma maneira para retornar para
a primeira tela, porém, ao solicitarmos a abertura da tela “Screen1” estaríamos, de fato, abrindo
uma nova “Screen1” e não retornando para a anterior.
O mesmo aconteceria ao mandarmos abrir “apagarLuz” em sequencia. Com o tempo uma
sobrecarga de memória ocorreria causando lentidão e outros problemas com o uso constante de
mudanças de telas até mesmo no aplicativo mais simples.
De fato, o que desejamos fazer é fechar a segunda tela aberta, automaticamente
retornando para a primeira. Assim, o bloco a ser usado para programar “apagarLuz” seria “close
screen”, também localizado em Control.
Figura 4.65. Bloco a ser elaborado em "apagarLuz" para retornar para a primeira tela.
Em situações onde desejamos apenas realizar a ação de retornar para uma tela anterior
podemos, alternativamente, utilizar da própria opção de retorno do celular. Para isso, devemos
selecionar um bloco do conjunto de blocos da própria tela “apagarLuz”.
116
Figura 4.66. Bloco que utiliza o botão do próprio dispositivo android para realizar uma ação.
Assim, como mostrado na figura acima, quando o botão de retorno do próprio dispositivo
Android for pressionado a tela será fechada, retornando para “Screen1”.
Por fim, feita a programação de “Screen1” (Fig. 4.64) e de “apagarLuz” (Fig. 4.65 e/ou
Fig. 4.66), podemos fazer o Build e testar o aplicativo.
ALTERAR IMAGENS NUMA MESMA TELA CLICANDO NUM BOTÃO

Embora tenhamos a opção de criar múltiplas telas utilizando a plataforma, em algumas
ocasiões pode ser interessante que desenvolvamos um aplicativo que aparenta ter várias telas
utilizando apenas “Screen1”.
Um exemplo de aplicabilidade envolve o uso do Bluetooth: quando utilizamos os blocos
para conexão via bluetooth, ao mudarmos de tela, mudamos também o conjunto de blocos
aplicados a essa tela (como pode ser observado no aplicativo anterior). Dessa maneira ocorre
então a perda dessa conexão.
Senso assim, o problema poderia ser solucionado, à partir do uso de componentes de
Layout do painel Palette, em Design, e da propriedade “visible” desses componentes. Com eles,
é possível imitar uma mudança entre telas fazendo, na verdade, uma alteração na visibilidade
dos layouts utilizados.
Para imitar a forma como os componentes são dispostos ao serem soltos no Viewer,
faremos uso do “VerticalArrangement”. Observe, nas próximas imagens, como a propriedade de
visibilidade afeta o componente quando desmarcada.
117
Figura 4.67. Localização e insersão do componente com propriedade "visible" (canto inferior direito
da imagem) marcada.
Figura 4.68. Viewer após desmarcar a propriedade “visible”.
Para o desenvolvimento do aplicativo utilizaremos as mesmas imagens de lâmpadas do

anterior. Observe a tabela a seguir com a lista dos componentes.
Em seguida, em Blocks será mostrado como a propriedade de visibilidade e outras podem
ser alteradas via programação.
118
Tabela 4.4. Componente do projeto de alternar imagens numa mesma tela e seus atributos
modificadas.
Onde
Components encontrar Properties Valor
Height Fill parente
VerticalArrangement1 Layout Width Fill parente
Desmarcar após inserir
Visible
Button1 e Image1
FontSize 20
Button1 Width Fill parente
User
(dentro de
Interface Shape Rounded
VerticalArrangement1)
Text Toque aqui para desligar
Height Fill parente
Image1 Width Fill parente
User
(dentro de
Interface Picture lampo.jpg*
Height Fill parente
VerticalArrangement2 Layout
Width Fill parente
FontSize 20
Button2 Width Fill parente
User
(dentro de
Interface Shape Rounded
Text Toque aqui para ligar
Height Fill parente
Image2 Width Fill parente
User
(dentro de
Interface Picture lampc.jpg*
* upload de imagens de lâmpada acesa e apagada feitos no painel Media.
Para facilitar a explicação e elaboração do aplicativo, primeiro criamos o layout com a

imagem da lâmpada acesa e o botão responsável por trocar para o layout com a imagem para
lâmpada apagada. Esse primeiro layout deve ser colocado como invisível (“visible” desmarcado).
A propriedade “ScalePictureToFit” possibilita o ajuste das imagens em qualquer
dispositivo.
Finalizada a construção como sugerida na tabela, podemos observar como o Viewer se
comporta quando manipulamos “visible”. Observe as próximas imagens:
119
Figura 4.69. Viewer conforme montagem solicitada.
Figura 4.70. Viewer, ao colocarmos os dois layouts, que deveriam ser sobrepostos, quando
marcamos os dois como "visible".
Figura 4.71. Viewer, ao desmarcarmos "visible" apenas de "VerticalArrangement2".
120
Antes de partimos para Blocks, devemos deixar Design como na Fig. 4.69 e, para que
não fiquemos perdidos, iremos renomear “VerticalArrangement1” para “LayoutLigado” e
“VerticalArrangement2” para “LayoutDesligado”, bem como “Button1” para “Desligar” e “Button2”
para “Ligar”. Ilustramos abaixo, pare recordar, uma renomeação.
Figura 4.72. Para renomear um objeto devemos selecioná-lo (1), precionar "Rename" (2), dar um
nome de interesse e, por fim, precionar "OK".
Figura 4.73. Painel Components com componentes renomeados.
121
Passaremos agora para a aba Blocks mostrando, logo abaixo, a programação por trás do
aplicativo e discutiremos os blocos utilizados na mesma.
Figura 4.74. Blocos necessários para funcionamento do aplicativo.
Muitos aspectos de determinados elementos podem ser modificados não apenas na aba
Designer como, também, em Blocks.
O projeto utiliza os seguintes blocos:
 When Ligar.click do – realiza uma ação ou evento quando o botão do aplicativo
é clicado.
 Set <component>.<aspect> to – é utilizado de diferentes maneiras para
estabelecer uma característica de um componente.
o Ao acessa-lo, pelo bloco relativo ao componente, <component> já terá
um nome específico que, no caso desse projeto, podem ser:
LayoutDesligou ou LayoutLigado e, por serem do mesmo tipo, podem
ser alternados entre si ao clicar no campo de seu nome, onde surgirá
uma lista com os nomes dados a esses elementos.
o O campo <aspect> de cada componente também pode ser encontrado
nas várias formas específicas, mas também podemos abrir uma lista
dos mesmos ao clicar em seu campo.
 Estrutura “true”/”false” do bloco Logic – é utilizado quando desejamos determinar
ou comparar algo como sendo verdadeiro ou falso (booleano).
122
Figura 4.75. Opções referentes a qual <component> será manipulado.
Figura 4.76. Opçoes referentes aos possíveis <aspects> que podem ser manipulados.
O projeto então elaborado, basicamente faz as mesmas manipulações que foram

demonstradas quando alteramos em Design o aspecto de visibilidade de cada layout. Marcar ou
desmarcar, em Design, tem a mesma ação que classificar o aspecto do componente como “true”
ou “false”.
O projeto está pronto para que sua Build seja feita e testada no aparelho.
123
5. Integração Arduino e App Inventor
Nesse capítulo trataremos sobre o desenvolvimento de aplicativos, utilizando App

Inventor, e programas para o microcontrolador Arduino capazes de se comunicarem uns com os
outros.
Essa interação será apresentada por três formas de comunicação diferentes: Bluetooth,
protocolo Ethernet e GSM. Mais detalhes sobre Shields, módulos ou demais questões que
contemplem o necessário para o funcionamento do sistema serão repassadas mais adiante
sendo explicados conceitualmente e sua relevância para o sucesso de tais sistemas.
Além disso, a comunicação será tratada em tempo real e de forma que uma resposta
clara sobre os comandos trocados possa ser adquirida pelo usuário do aplicativo, sendo um dos
tópicos de maior importância para um diálogo “inteligente” entre as partes que compõe o
mecanismo de controle entre as plataformas a obtenção dessas respostas.
5.1. Por que integrar as duas plataformas?
É notória em nosso cotidiano o uso de dispositivos móveis tal como o celular, que nos
acompanham já como parte de nós, armazenando compromissos, facilitando a comunicação e
nos interligando com novas pessoas, compartilhando informações e nosso cotidiano, facilitando
transações bancárias, pagamentos e compras. Por que, então, não utilizarmos do poder que um
microcontrolador pode nos oferecer para manipular ferramentas de nosso interesse?
Unindo aplicativos e as capacidades de um microcontrolador podemos realizar, à
distância, o controle de elementos muito mais interessantes que um LED. Podemos manipular e
automatizar todas as lâmpadas de uma casa, abrir ou fechar o portão de casa, dentre muitas
outras coisas.
Muito disse já é feito hoje em dia a partir de controles remotos, mas um microcontrolador
pode ser facilmente conectado a uma rede Wi-Fi, bem como um celular faz hoje em dia. Com
isso temos ganhos em distância, qualidade e segurança da resposta, tendo em vista que
podemos construir o sistema como desejarmos e solicitar dele confirmações e checagem de
informação.
Sendo assim, saber o básico de como é possível fazer isso e utilizando ferramentas
simples, mas de grande potencial é de grande importância para a elaboração de sistemas
modernos de controle.
124
5.2. Comunicação com realimentação efetiva em tempo real
Cada projeto a ser elaborado terá como função o envio de uma solicitação por parte do
aplicativo desenvolvido no App Inventor e o seu recebimento e ação consequente da solicitação
por parte do Arduino e o programa desenvolvido no IDE do mesmo. Além disso, o sistema trará
consigo uma comunicação com realimentação efetiva.
A realimentação efetiva trata-se de uma resposta dada ao que foi solicitado, ou seja, o
Arduino não apenas seria responsável por receber a solicitação e executar uma ação à partir da
solicitação recebida em seu sistema como, também, seria responsável pelo envio de uma
resposta sobre o que de fato ocorreu após a execução da ação pretendida.
É importante o entendimento sobre um sistema realimentado (com resposta) e um
sistema sem realimentação (sem resposta) para que possamos compreender como controlar de
forma efetiva um comando enviado relacionando o que existe no mercado e o que se espera de
um produto produzido por um profissional com nível superior de qualidade. Para isso, alguns
conceitos importantes são necessários.
MODELO CLIENTE-SERVIDOR
Sempre que se fala em cliente-servidor vem à mente redes de computadores. Isso não
está errado, mas é preciso ir mais fundo para entender o que realmente vem a ser um cliente e
um servidor.
A tecnologia cliente-servidor é uma arquitetura na qual o processamento da informação
é dividido em módulos ou processos distintos. Um processo é responsável pela manutenção da
informação (servidores) e outros responsáveis pela obtenção dos dados (os clientes).
Os processos cliente enviam pedidos para o processo servidor, e este por sua vez
processa e envia os resultados dos pedidos.
Dessa forma podemos utilizar uma analogia para entender o principio de cliente e
servidor. Imaginemos a ação de ligar um aparelho de TV pelo controle remoto. Ao se apertar o
botão no controle o televisor irá ligar ou não. Nesse contexto o controle se comporta como um
Servidor e o televisor se comporta com um Cliente.
 Se ao pressionar o botão o televisor não ligar teremos uma resposta áudio/visual

da situação, ou seja, o televisor não emitiu som e nem imagem e neste caso
saberemos por outros meios que o televisor não ligou. Se o televisor ligar.
125
 Se ao pressionar o botão o televisor ligar teremos uma resposta áudio/visual da
situação, ou seja, o televisor emitiu som e imagem e neste caso saberemos por
outros meios que o televisor ligou.
Essa situação mostra que a comando não obtém resposta pelo mesmo meio de
transmissão. No controle não chega nenhuma informação de que o televisor ligou.
Para tornar o caso mais inteligível suponha-se que estivéssemos de olhos vendados e
ouvidos abafados e quiséssemos executar a mesma ação de ligar o televisor. Neste caso não é
sabido após se executar o comando se o televisor ligou ou não ligou. Com isso conclui que o
Cliente é sempre Cliente e o Servidor é sempre Servidor.
Para resolver esse problema pode-se desenvolver um controle com algum tipo de
dispositivo vibratório e a cada comando enviado ao televisor e executado com sucesso uma
vibração ocorra no controle e o usuário saberia se a ação foi concluída. Uma vez que isso ocorra
fica claro que o Cliente e Servidor invertem seus papéis mediante a necessidade.
Quando temos um sistema com realimentação efetiva, como os que serão apresentados
nos experimentos a seguir, temos um equivalente ao televisor que irá receber a solicitação para
ligar ou desligar e retornará ao controle do solicitante um evento informando sobre o resultado
da solicitação de modo a ser facilmente compreendida.
RESPOSTA EM TEMPO REAL

O controle a distância com resposta em tempo real é outro personagem importante
quando tratamos sobre o controle de sistemas. É preciso entender o real conceito do termo
“tempo real”, evitando equívocos de interpretação.
Num primeiro momento imaginamos como sendo tempo real algo instantâneo. No
entanto, isso não é verdade e pode causar efeitos indesejáveis quando se trata de
desenvolvimento de projeto.
Um sistema em tempo real é, na verdade, aquele que satisfaz restrições de tempo na
entrega de suas respostas. Para isso, devemos ficar atentos nos tempos de transmissão de
mensagens, no de execução de tarefas, dentre outros, para que atrasos não ocorram, tendo em
vista que os mesmos podem acarretar em consequências negativas ou levar o sistema à falha.
Podemos exemplificar de duas formas para melhorar o entendimento:
 Um sistema que simule uma gestação humana com todo o desenvolvimento do
bebê. Tal sistema não poderá fornecer a resposta do nascimento do bebê antes
dos nove meses previstos. Caso demore mais que o tempo previsto de nove
meses, saberemos que há um erro com o simulador o que pode afetar
126
negativamente a resposta ou tornar o sistema completamente insatisfatório por
incompatibilidade com o ciclo de gestação, o qual deveria seguir.
 Precisamos saber sobre a situação de alguém que mora distante. Podemos
escrever uma carta e aguardar a resposta que levará dias ou semanas,
dependendo da forma de envio escolhida junto aos Correios, ou podemos ligar e
saber as notícias desejadas. Pelos correios, o atraso na troca de cartas pode
aumentar nossa preocupação com a pessoa distante e, por telefone, uma
consequência de um atraso na resposta seria a difícil compreensão do que a outra
pessoa está dizendo e interpretarmos erroneamente.
No primeiro exemplo temos uma clara situação onde a palavra “instantânea” ou “rápida”
não condizem de uma maneira assertiva com o é “tempo real”. Da mesma forma, no segundo
exemplo, temos uma situação onde, mesmo que o meio mais utilizado hoje em dia sejam os
telefones para a comunicação com alguém distante, cartas podem nos dar igualmente um
sistema em tempo real, caso os dois cumpram seus prazos de entrega da mensagem.
Os danos dos atrasos vão depender de cada sistema e, para cada implementação em
tempo real, esse dano pode ser mais ou menos crítico.
5.3. Comunicação via Bluetooth
O Bluetooth é uma rede sem fio utilizada para a conexão e troca de informações entre
dispositivos diversos (celulares, impressoras, videogames etc.). É um protocolo de comunicação
de baixo alcance, classificado como uma WPAN (do inglês: Wireless Personal Area Networks –
rede sem fio de área pessoal) e iremos utiliza-lo para comunicação próxima entre um smartphone
Android e um Arduino Uno.
A rede será utilizada para o controle a distância de uma lâmpada que será conectada ao
Arduino e terá realimentação de confirmação efetiva das ações às solicitações, repassadas do
smartphone para o Arduino, em quatro quadrantes.
Baseando-nos no que foi apresentado nos tópicos anteriores, a realimentação de
confirmação efetiva trata, então:
 do envio de uma solicitação para o controle da lâmpada (acende-la ou apaga-la)
pelo smartphone;
 execução dessa solicitação por parte do microcontrolador;
 avaliação subsequente, realizada a partir de um sensor, enviando um resultado
ao microcontrolador de se a ação foi bem sucedida ou não;
127
 entrega desse resultado da ação solicitada ao solicitante.
Assim, é possível observar que o microcontrolador altera sua função na arquitetura
cliente-servidor, ora responsável por manter informações e fornecer, ora pela sua aquisição.
Entendido isso, as respostas possíveis do sistema são as seguintes:
1. Acionamento solicitado: resposta positiva para a ação de acionar a lâmpada;
2. Acionamento solicitado: resposta negativa para a ação de acionar a lâmpada;
3. Desligamento solicitado: resposta positiva para a ação de desligar a lâmpada;
4. Desligamento solicitado: resposta negativa para a ação de desligar a
lâmpada.
Para o andamento da montagem e seu entendimento, discutiremos, previamente, os

novos componentes e circuitos que serão utilizados.
MÓDULO BLUETOOTH RS232 HC-05

O HC-05 será o módulo Bluetooth utilizado, tendo o mesmo um regulador de tensão,
podendo ser alimentado com tensões entre 3.3 e 5V, um LED indicador, para saber se o módulo
está pareado com outro dispositivo, e alcance de até 10 metros. Possui também suporte para
modo mestre e escravo, ou seja, é passivo na comunicação (escravo) recebendo dados e
também é capaz de estabelecer comunicação com outros dispositivos.
Figura 5.1. Típico módulo Bluetooth HC-05.
128
O módulo possui 6 pinos, cujas indicações do mesmo podem ser encontrados no verso
da placa, sendo eles:
 EN (ou KEY, pode variar de acordo com o fabricante): habilita (enable) o modo
de configuração via comandos AT, quando o pino recebe sinal de altas antes
da placa ser energizada;
 VCC: refere-se a tensão de alimentação (5V ao conecta-lo ao arduino);
 GND: é o terra do sistema (ou do próprio Arduino);
 TXD: transmite dados seriais do módulo para o receptor serial do Arduino
(RX);
 RXD: recebe dados seriais do transmissor serial do Arduino (TX);
 STATE: informa se o módulo está conectado ou não.
Embora a alimentação do HC-05 possa ser de 5V, a comunicação serial do módulo

selecionado funciona com nível de tensão de 3.3V sendo prejudicial devido a tensão enviada
pelo Arduino ao mesmo ser de 5V. Para isso, devemos utilizar um divisor de tensão, evitando
que o componente seja danificado.
DIVISOR DE TENSÃO
Um divisor de tensão nada mais é que uma técnica para gerar uma proporção entre duas
tensões utilizada em projetos quando é necessário, por exemplo, a manipulação de um sinal a
ser recebido por um dispositivo. No nosso caso, o dispositivo de interesse é o HC-05 e desejamos
um nível próximo de 3.3V, sendo o sinal de entrada de 5V.
Figura 5.2. Diagrama do circuito do divisor de tensão.
Conforme apresentado na Fig. 5.2, o circuito consiste em dois resistores em série e o

cálculo do valor de nível de tensão de saída é calculador pela formula:
129
𝑅2
𝑉𝑜𝑢𝑡 = 𝑅1 +𝑅2
× 𝑉𝑖𝑛 (1)
Consideremos um resistor de R1 = 1.5kΩ, um R2 = 2,4kΩ (valores comerciais de

resistores) e a tensão de entrada de 5V. Utilizando a equação (1) e substituindo os valores
teremos uma tensão de saída de aproximadamente 3.1V, suficiente para o funcionamento do
sistema sem que haja perdas e/ou danos no módulo Bluetooth.
MÓDULO RELE
Como dito no início do material, utilizaremos o sistema para o controle à distância de uma
lâmpada. Uma lâmpada residencial comum funciona com uma tensão de 127V ou 220V, ambos
valores de carga que o Arduino não consegue administrar.
Para que possamos controlar uma lâmpada iremos então associa-la a rede elétrica local
de modo que o microcontrolador possa manipular seu funcionamento e, ao mesmo tempo, não
seja afetado pela corrente e tensão imensamente superior à que é capaz de suportar.
Para solucionarmos essa questão, falaremos novamento sobre o uso de um rele: um
dispositivo eletromecânico formado, basicamente, por uma bobina (nesse caso, um núcleo de
aço maciço envolto por um fio de cobre), armadura de ferro móvel, contatos fixos e um móvel e
seus terminais.
Figura 5.3. Ilustração dos elementos constituintes de um relé. Fonte:

https://download.pearltrees.com/s/pic/or/-95274746. Acesso em novembro, 2017.
130
Quando uma corrente passa pela bobina do relé, é gerado um campo magnético que atrai
o contato da armadura, o que pode abrir e/ou fechar uma série de circuitos. Cessada a corrente,
os contatos voltaram para suas posições normais (originais).
Quanto aos contatos, podemos encontrar relés normais abertos (NO), os quais estão em
aberto quando não há energia na bobina, normais fechados (NC), abertos quando há, e ainda
temos aqueles com ambos os contatos, como é o caso do relé da Fig. 5.3. Nessa configuração,
o relé possui um contato comum (C), o responsável por estabelecer condução quando NO fecha
e contato com NC quando ele fecha.
Nos terminais da bobina teremos o Arduino energizando-a e ainda uma conexão a um
pino digital, pelo qual serão repassados comandos para acionar ou desligar o rele. Nos terminais
NO/NC e C, teremos a conexão com a rede de energia para que, dado o sinal do Arduino, haja
comutação dos contatos, sendo eles responsáveis pelo estado da lâmpada.
Como a comutação de estado é dado pela questão que envolve um campo
eletromagnético gerado, não há nenhuma necessidade de contato direto do circuito do Arduino
com o da lâmpada estão, assim, um isolado do outro. Porém, embora solucionadas as questões
que envolvem tensão elétrica, ainda são necessárias algumas precauções com a corrente no
sistema.
Como a corrente que transita no sistema ainda é superior a suportada pelo Arduino, um
transistor é adicionado ao circuito, tendo seu emissor ligado ao GND, a base à saída digital de
controle utilizada e o coletor ao relé. Assim, a corrente que poderia danificar o microcontrolador
quando o relé estiver ativado fluirá para o GND.
Temos agora o Arduino protegido, mas ainda assim, quando desenergizamos a bobina,
desfazendo o campo magnético, a indutância do relé tentará manter a corrente no circuito. Essa
corrente, que surge em sentido reverso, irá danificar o transistor e, em certo ponto, a proteção
que tentamos dar ao diodo terá sido em vão.
Para resolver mais esse problema, utilizamos um diodo conectado em paralelo, e em
sentido reverso, ao relé. Esse diodo é conhecido como freewheeling e promove um caminho para
a circulação de corrente até que a indutância do relé perca toda sua energia, evitando danos a
todo sistema.
Todos esses elementos unidos à um resistor, também para controle de corrente que irá
para o Arduino e àquela que fluirá para seu GND com o auxílio do transistor, formam o chamado
módulo relé. Encontramos módulos comercialmente distribuídos com especificações para
diversas aplicações e utilizaremos um na construção do nosso sistema, como será apresentado
mais adiante.
131
Figura 5.4. À esquerda, um módulo relé de 1 canal e, à direita, um diagrama dos componentes de
um módulo com transistor NPN. Q1 representa o transistor, D1, o diodo, R, o resistor e RLY, o relé.
MONTAGEM DO SISTEMA
Para elaborar o sistema de controle com módulo Bluetooth serão necessários os
seguintes componentes:
 Arduino;
 Módulo relé 5V, de um canal;
 Módulo Bluetooth RS232 HC-05;
 Um Resistor de 1.5kΩ, um de 2.4kΩ e um de 10kΩ;
 Um LDR (Light Dependent Resistor – Resistor Dependente de Luz);
 Jumpers (macho-macho e macho-fêmea);
 Protoboard;
 Bocal termoplástico adaptável com plug macho;
 Plug macho de dois pinos/10A para tomada;
 Tomada externa retangular 10A;
 Lâmpada 127/220V (dependendo da rede em uso);
 Fio flexível branco 1.5mm.
A conexão do relé será dada diretamente a rede elétrica pelo seu terminal comum (C) e
o normal aberto (NO) será utilizado para conectar um dos terminais da lâmpada e, em sequência,
conectar o outro terminal da lâmpada à rede.
O LDR fará parte de um novo divisor de tensão, sendo ligado em um pino analógico do
microcontrolador.
132
LDR
Figura 5.5. Esquema da montagem do projeto de comunicação via Bluetooth.
133
FUNCIONAMENTO DO SISTEMA
O sistema deverá, inicialmente, realizar um pareamento entre o módulo Bluetooth e o
dispositivo Android. Feito isso, o smartphone irá realizar uma solicitação ao Arduino, a qual será
enviada pela rede Bluetooth quando os dois estiverem conectados, e o microcontrolador, ao
receber tal solicitação, irá verifica-la e executar uma ação correspondente.
Até aqui temos o sistema funcionando de forma simples, com a solicitação para
acionamento ou desligamento sendo realizada, porém, como foi dito anteriormente, desejamos
um sistema com realimentação ativa, que possa não apenas realizar as ações, mas verifica-las.
É aqui que entra um componente que foi listado e mostrado no esquema do circuito, porém, não
foi explicado: o LDR.
O LDR é um componente resistor cuja resistência varia de acordo com a luminosidade do
ambiente, funcionando como um sensor prático e de baixo custo. Quanto maior a luminosidade
do ambiente, menor será sua resistência (podendo chegar à 8Ω), aumentando de acordo com a
diminuição da luz que o afeta (chegando à 1.0MΩ). Sendo assim, podemos utiliza-lo em uma
porta analógica do Arduino e atribuir um parâmetro de forma que, variado acima ou abaixo do
mesmo, tenhamos uma resposta sobre o acionamento da lâmpada.
No circuito, sua montagem é realizada como um divisor de tensão e seu sinal pode ser
representado digitalmente no Arduino numa variação de 1024 valores (0-1023) e, a partir dessa
faixa de valores e de questões do ambiente no qual o sistema for montado, decidiremos o valor
do parâmetro.
É importante estar atento quando o programa for carregado na placa para que o módulo
bluetooth esteja desconectado da mesma. Como o carregamento via USB utiliza as portas seriais
do Arduino, o Bluetooth pode causar interferência nesse procedimento impedindo a execução do
procedimento. Caso seja de interesse, existe uma função chamada SoftwareSerial, utilizada para
que diferentes portas digitais funcionem para a comunicação serial, podendo ser testada para o
funcionamento do bluetooth e modificações do código sem a necessidade de desconexão do
módulo a cada novo teste.
134
Figura 5.6. Recorte do circuito para melhor visualização das conexões e do LDR (circulado).
O divisor de tensão no qual o LDR está inserido pode ter duas configurações que
modificam a forma como a resposta deve ser trabalhada, consequentemente, como o código
deve ser trabalha.
Usando de base a Fig. 5.2., quando LDR assume a posição de R1, uma maior tensão de
saída será observada quanto maior for a luminosidade. A luminosidade diminui a resistência e,
135
consequentemente, mais tensão chegará na saída, ligada ao pino analógico. A conversão do
valor analógico para digital dará um valor inteiro maior, nessa situação.
Na configuração onde o LDR ocupa a posição de R2, a baixa luminosidade impede a
circulação para o GND fazendo com que uma maior tensão chegue ao pino analógico.
PROGRAMAÇÃO NO ARDUINO
Para esse projeto serão introduzidos alguns tipos diferentes de variáveis, funções e pinos
utilizados, esclarecendo seus detalhes anteriormente ou posteriormente ao código dependendo
da conveniência e de forma a tornarmos mais visual a situação de funcionamento.
Como já foi apresentado e mostrado na Fig. 5.5 e Fig. 5.6, para a realimentação ativa do
sistema utilizaremos como sensor diretamente associado a lâmpada o LDR ligado em um pino
analógico do Arduino. O pino analógico de interesse, conforme figuras, é A2 e pode ser declarado
como um inteiro com valor “A2” ou, simplesmente, “2”.
Sobre a detecção de luminosidade, podemos simplesmente atribuir um valor à uma
variável e uma detecção acima ou abaixo desse valor nos daria a resposta sobre o estado da
lâmpada após repassada a informação de ação. Porém, podemos tornar o sistema mais confiável
e prático, fazendo com que o Arduino meça a luminosidade do ambiente repassada pelo LDR e
tome o valor lido de base para saber se a carga foi ou não acionada. Veremos isso com mais
clareza após apresentado o código.
Faremos a declaração de alguns pinos (analógico e digitais) como const int, cujo valor
inteiro declarado não pode ser alterado no decorrer do código, apenas lido, acusando erro
durante a compilação se houver tentativa de atribuição de novo valor à variável. Esse tipo de
variável é uma melhor opção para declarações de pinos ou outros elementos que são fixos,
podendo ser usado também para tipos float, char, string etc.
Será introduzida, também, a função millis() do Arduino que realiza a medida de tempo,
em milissegundos, desde que o mesmo iniciou o programa recentemente em funcionamento.
Como essa contagem entra em overflow (retorna à zero) somente após 50 dias (caso o Arduino
funcione initerruptamente), utilizaremos a declaração unsigned long para variáveis que
manipulem esse tempo7.
No início do código foram estabelecidos os nomes das variáveis, seus tipos e valores
iniciais (em algumas delas).
7 O uso de outro tipo de declaração que não unsigned long para cálculos aritméticos que envolvem uma unsigned long, tal
como é utilizado pela função millis() pode acarretar em erros.
136
const int rele = 4; //pino de acionamento do rele
const int analogPin = 2; //pino de leitura analogica do LDR
int ambiente = 0; //variável para luminosidade ambiente medida

int LDR = 0; //variável auxiliar para leitura ambiente
char leituraBT; //leitura dos caracteres recebidos via Bluetooth

int resposta; //armazena valor inteiro da leitura LDR para saber
//resposta da ação solicitada
Em seguida, no setup(), foi introduzido, além da inicialização do pino digital, um while-

loop responsável pela verificação inicial de luminosidade do ambiente no qual o sistema
embarcado do Arduino está situado. O loop dura 5 segundos (5000ms) e durante realiza uma
verificação da luminosidade que está afetando o LDR sendo o maior valor encontrado
armazenado na variável “ambiente”. Pinos analógicos funcionam como entrada (input) por
padrão, não necessitando de um comando de inicialização.
void setup() {
pinMode(rele, OUTPUT); //pino ligado ao rele como saída de dados
Serial.begin(9600); //inicio da comunicação serial taxa de 9600
/*pega leitura do LDR no local por 5 segundos e armazena o maior valor em

"ambiente". Esse loop eh utilizado para substituir um valor fixo de
luminosidade fazendo com que o sistema se adeque automaticamente onde estiver
ao ser inicializado*/
while (millis() < 5000){
LDR = analogRead(analogPin);
if(LDR > ambiente) ambiente = LDR;
}
Serial.print("Valor inicial de luminosidade do ambiente: ");
Serial.println(ambiente); //manda para serial monitor o maior valor
// de luminosidade obtido
}
Em ambientes onde a luminosidade é controlada e constante poderíamos desconsiderar

esse loop e apenas estabelecer um valor para “ambiente” que seria inalterado, tendo em vista
que o meio no qual o LDR está inserido não faria com que ele sofresse alterações ao longo do
tempo. Porém, o uso do loop permite que o sistema, independentemente de onde se encontre,
137
tenha uma maior autonomia, sem a necessidade de intervenção constante no código para
ajustes.
A mesma ideia é utilizada quando introduzimos a função DetectaLuzTempo(), que
permite ao sistema realizar uma auto calibração ao longo do tempo. Como conversado no
primeiro capítulo, utilizamos a função para deixar o loop() mais enxuto e, estando onde estiver
no programa, a mesma será chamada, executada suas instruções e voltará ao loop() na
sequência.
void loop() {
DetectaLuzTempo();
/* função para que, após a verificação inicial, a analise de luminosidade
seja feita a cada determinado periodo de tempo pré-determinado do millis().
OBSERVAÇÃO: essa função é interessante para, por exemplo, quando o
equipamento for utilizado num determinado intervalo de tempo em local onde
haja variação de iluminação (ex.: operação em céu aberto) */
if(Serial.available()){
leituraBT = Serial.read();
if(leituraBT = 'A') digitalWrite(rele, LOW);
if(leituraBT = 'D') digitalWrite(rele, HIGH);
}
//verifica se o q está sendo lido pelo LDR após a solicitação de
//ligar/desligar lampada
resposta = analogRead(analogPin);
if(resposta > ambiente){

Serial.write('L');
Serial.write('i');
Serial.write('g');
Serial.write('a');
Serial.write('d');
Serial.write('o');
Serial.write(' ');
Serial.write(' ');
Serial.write(' ');
}
else{
Serial.write('D');
Serial.write('e');
Serial.write('s');
Serial.write('l');
Serial.write('i');
Serial.write('g');
Serial.write('a');
Serial.write('d');
138
Serial.write('o');
else{
Serial.write('D');
Serial.write('e');
Serial.write('s');
Serial.write('l');
Serial.write('i');
Serial.write('g');
Serial.write('a');
Serial.write('d');
Serial.write('o');
Serial.write(' ');
Serial.write(' ');
Serial.write(' ');
}
}
Sendo assim, executada a função, seguimos para a verificação da existência de algum

dado disponível para leitura serial, marcando o início da comunicação Bluetooth. As mensagens
recebidas via Bluetooth, mandadas pelo aplicativo foram estipuladas como sendo “A”, para o
acionamento e “D”, para desligar. Quando o Arduino verifica a disponibilidade de um dado para
leitura, esse dado será lido e armazenado na variável “leituraBT” e a estrutura “if” é utilizada para
determinar a ação a ser enviada ao pino do relé (o circuito tem sua montagem de tal forma que
o acionamento será dado com sinal de baixa).
Como já deve ter sido observado na estrutra “while” do setup(), o “if” foi montado de uma
maneira um pouco diferente. Isso se deve ao fato de que certas linguagens de programação
permitem que algumas estruturas sejam escritas de formas diferentes. Nesse caso, quando a
estrutura possui apenas uma linha de instrução, não é necessário o uso dos colchetes e,
portanto, foi escrita na frente da condição para economia de linhas e uma melhor visualização.
A variável “resposta” é comparada com “ambiente” e caso a primeira seja maior que a
segunda isso significa que uma maior quantidade de luz está sendo observada pelo sistema,
tendo em vista que o LDR terá sua resistência diminuída na presença de uma luminosidade mais
intensa e, portanto, uma maior tensão será recebida no pino analógico aumentando o seu valor
inteiro lido na escala de 0-1023.
Deduzimos que a causa disso é a lâmpada estar acionada e, assim, uma mensagem
pertinente será enviada serialmente, via Bluetooth, ao dispositivo Android sendo apresentada na
tela do aplicativo intermitentemente a mensagem “Ligado “, até que o estado mude (e a
mensagem seja “Desligado “) ou a conexão com o Arduino seja encerrado.
139
Vale notar que, nesse sistema, essa mensagem independe da solicitação, sendo essa
uma montagem simples do mesmo. Caso seja de interesse, alterações podem ser realizadas de
acordo com suas habilidades adquiridas ou já existentes na linguagem.
Voltando para a função DetectaLuzTempo(), temos o uso do tipo unsigned long para
as manipulações do tempo com millis(). Aqui faremos a decisão do intervalo de tempo em
que a variável “ambiente” será atualizada com a luminosidade local, conforme dito anteriormente.
Assim, sendo a diferença de atualMillis e anteriorMillis maior que o valor de “tempo”, a
estrutura condicional que os compara será a responsável por verificar se o relé está acionado,
pois mudar o valor de “ambiente” nessa situação pode levar a uma informação errada sobre o
estado da lâmpada, e sendo a situação propícia, o valor de “ambiente” será reestabelecido para
condizer com a situação atual de luminosidade do local onde o sistema está posicionado.
140
void DetectaLuzTempo(){
//variaveis iniciadas para contagem de tempo
unsigned long atualMillis = millis();
unsigned long anteriorMillis = 0;
unsigned long tempo = 1800000;
/*verificada a passagem do tempo (por exemplo: 1800000ms = 30min)

pre-determinado, será iniciada uma nova verificação da luminosidade
do ambiente*/
if (atualMillis - anteriorMillis >= tempo) {
//salva o ultimo tempo no qual foi realizada a verificação de
// luminosidade após a inicial
anteriorMillis = atualMillis;
/*se a lampada estiver ligada, a

atualização é um fator que pode perturbar a resposta real*/
if(digitalRead(rele) == LOW)
Serial.println("Lampada ainda acionada, verificação de luminosidade
ambiente não atualizada");
else{
//leitura feita conforme em setup()
ambiente=0;
while(millis()-anteriorMillis < 5000){
}
Serial.print("Luminosidade atualizada: ");
Serial.println(ambiente);
}
}}
Em resumo, temos:
 Iniciação das variáveis necessárias;
 Inicialização dos pinos utilizados e do while-loop para calibrar a luminosidade em
setup();
 Verificação cíclica do tempo através da função DetectaLuzTempo() em loop()
com calibração da luminosidade após dado intervalo desse tempo;
 Recebimento de dados via Bluetooth por parte do Android, armazenamento e
verificação do seu valor para que uma ação seja tomada por meio de um dos “if”
(acionar ou desligar lâmpada);
 Envio de mensagem ao Android relativo ao estado da lâmpada.
141
DESENVOLVIMENTO DO APLICATIVO NO APP INVENTOR
O aplicativo utilizará a conectividade Bluetooth do dispositivo Android e para isso alguns
blocos de alerta também serão postos para que estejamos cientes da necessidade de conexão
e ativação de sua rede. Além disso, é necessário que, ligado o Bluetooth, seja feito um
pareamento entre as vias do sistema.
Tabela 5.1. Componentes para projeto de Comunicação via Bluetooth. (continua)

AlignHorizontal Center : 3
Inicia com BackgroundImage bt.png
Screen1
projeto Icon BT_icon.jpg
TitleVisible desmarcar
BackgroundColor black
FontSize 20.0
HasMargins desmarcar
Label1 User Interface
Text BLUETOOTH
TextAlignment Center : 1
TextColor Cyan
BackgroundColor None
HorizontalArrangement1 Layout
Width Fill parent
BackgroundColor Green
FontBold marcar
CONECTAR (Button) User Interface Width Fill parent
Shape Rounded
Text CONECTAR
BackgroundColor Red
FontBold marcar
DESCONECTAR (Button) User Interface Width Fill parent
Shape Rounded
Text DESCONECTAR
BackgroundColor black
FontSize 18.0
Label2 User Interface
Text CONTROLE
TextColor Cyan
Width Fill parent
142
Tabela 5.1. Componentes para projeto de Comunicação via Bluetooth. (conclusão)
FontBold marcar
Ligar (Button) User Interface Width Fill parent
Shape Rounded
Text Ligar
BackgroundColor Red
FontBold marcar
Desligar (Button) User Interface Width Fill parent
Shape Rounded
Text Desligar
FontBold Marcar
FontSize 20.0
STATUS (Label) User Interface
Text STATUS
TextColor Yellow
FontBold marcar
FontSize 20.0
AGUARDANDO... HasMargins desmarcar
(Label) User Interface Text AGUARDANDO...
TextColor Green
ListPicker1 User Interface Visible desmarcar
Notifier User Interface - -
BluetoothClient1 Connectivity - -
Clock Sensors - -
Na tabela acima, os componentes cujos nomes estão entre parênteses e um outro nome
é apresentado anteriormente sinalizam aqueles cujos nomes foram alterados pelo uso do
“Rename”, como já explicado ser possível no capítulo anterior.
Foram criados dois botões relativos a solicitação de conexão e desconexão com um
dispositivo Bluetooth. Ao clicar em “CONECTAR” será aberta uma lista, o “ListPicker1”, com
todas as redes Bluetooth pareadas disponíveis e “DESCONECTAR” finaliza o conexão realizado
com uma dessas redes.
Os outros dois botões, “Ligar” e “Desligar”, são os responsáveis pelo envio da solicitação
de acionamento (mensagem “A”) e desligamento (mensagem “D”), respectivamente, ao Arduino.
143
O texto “AGUARDANDO...” será substituído pelas mensagem “ligado ” ou “desligado
”, após a conexão, conforme o estado em que a lâmpada se encontra.
Os componentes não visíveis “Notifier1”, “BluetoothClient1” e “Clock1” são utilizados,
respectivamente, para exibir notificações no aplicativo conforme programado em Blocks, permitir
o funcionamento do cliente Bluetooth através do aplicativo, e para contagem de tempo, utilizada
para um loop de recebimento de mensagens através do Bluetooth, conforme veremos.
Em “Screen1” foram utilizadas duas imagens, cujo upload foi realizado em “Media”:
BT_icon.jpg, referente ao ícone do aplicativo no dispositivo Android, e bt.png, referente ao fundo
de tela do aplicativo.
Demais componentes foram utilizados para identificação de cada região do aplicativo e
ao que os botões se referem (labels), além daqueles com função de aperfeiçoamento do layout
do aplicativo (arrangements).
É interessante lembrar que, caso seja de interesse, é possível alterar o nome do aplicativo
que aparecerá no dispositivo Android após a intalação do apk fazendo a modificação do
“AppName” em “Screen1”.
Figura 5.7. À direita, imagem utilizada para fundo de tela do aplicativo e, à esquerda, ícone do
aplicativo. Fonte: pesquisa por imagens da palavra-chave “bluetooth”.
144
Figura 5.8. Layout no Viewer após montagem dos componentes.
Partindo agora para a programação, discutiremos cada parte a partir da exibição de

figuras de cada um dos blocos montados.
Figura 5.9. Bloco responsável por notificação em tela em caso de indisponibilidade do Bluetooth.
A peça “when Screen1.Initialize do” é responsável por realizar uma ação ou evento
quando a tela em questão do aplicativo for inicializada seja ao abrir o aplicativo pela primeira vez
ou pela comutação entre telas.
145
Assim, inicializar o aplicativo é feita uma verificação de se o Bluetooth do celular está
habilitado. Caso ele não esteja, uma caixa de diálogo da notificação com opções de escolha
(Notifier1. ShowChooseDialog) aparecerá na tela informando a necessidade de que o mesmo
esteja ativo e dando dois botões possíveis de serem clicados. A mensagem pode ser cancelada
detectando-se a conexão entre o dispositivo Android e o Arduino.
Figura 5.10. Notificação apresentada em tela no caso de o Bluetooth do dispositivo Android não
estar conectado.
Como podemos observar, a verificação de conexão foi feita por uma peça condicional: “if-
then”. A estrutura, funciona de maneira análoga ao if apresentado no primeiro capítulo, ao
falarmos das estrtuturas condicionais, de modo a realizar um determinado evento verificada a
obediência de uma dada condição.
Nesse ponto já é possível entender que, para encontrarmos um bloco que seja mais
“geral” devemos verificar sua cor e procurá-lo em Built-in. O bloco de interesse no momento
pertence aos blocos de controle (control) e pode ser expandido para melhor desenvolvimento da
estrutura condicional de interesse.
Figura 5.11. Localização do bloco condicional "if then" na aba Blocks.
146
Figura 5.12. Bloco "if-then" antes e depois da conexão do bloco "else if", selecionado no menu de
configuração (engrenagem).
Em “if” e “else if” devemos colocar as condições. A tradução desses termos seriam “se” e
“senão se” e, sendo assim, quando as condições impostas por uma das estruturas conectadas à
essas forem satisfeitas, a regra subsequente em “then” (“então”) será aplicada. Ao utilizarmos
“else” (“se não”), a condição a ser satisfeita é a de que nenhuma das anteriores obteve sucesso
nos restando apenas a aplicação de uma dada regra de interesse.
Quando uma das opções é selecionada entramos num novo bloco referente ao que pode
ocorrer depois da escolha (.AfterChossing) com duas saídas:
 OK – mostra um alerta (Notifier1.ShowAlert) na tela com o aviso (notice): “Ative o
Bluetooth antes de usar o app”;
 Sair – encerra o aplicativo.
Figura 5.13. Bloco com as ações possíveis dependendo de qual botão foi pressionado.
147
Figura 5.14. Alerta apresentado caso “Ok” fosse pressionado.
Passadas essas estruturas iremos agora para os blocos referentes aos botões, a começar
pelo “CONECTAR”.
Figura 5.15. Bloco resposável por conectar o dispositivo móvel ao Bluetooth.
Ao clicar no botão é feito primeiramente uma verificação de se o Bluetooth foi ou não

acionado e caso não tenha sido um novo alerta será mostrado na tela. Mas sendo o caso de a
conectividade Bluetooth ter sido ativada, o botão fará com que seja aberta uma lista (ListPicker1
.Open) para que possamos escolher um dispositivo Bluetooth que já tenha sido pareado.
Figura 5.16. Alerta quando não há conectividade Bluetooth e "CONECTAR" foi clicado.
148
Figura 5.17. Lista de seleção de dispositivos pareados após clicar em "CONECTAR", com Bluetooth
ligado.
A lista de seleção possui dois blocos especificados um para a ação anterior a seleção de
uma conexão (conforme figura acima) e outra com uma condição após a seleção, que nos dá
uma alerta de erro caso a conexão com o endereço tenha falhado por algum motivo.
Figura 5.18. Blocos referente a lista de seleção de antes e depois de ser selecionada uma opção.
Figura 5.19. Alerta de erro quando o item selecionado não estabelesse conexão.
Para a solicitação de desconexão entre o Bluetooth e o dispositivo móvel temos o botão

que utiliza os blocos de “DESCONECTAR”.
149
Figura 5.20. Bloco responsável por desfazer a conexão com o Bluetooth.
Ao clicar no botão é feito, primeiramente, uma verificação da conexão. Caso ela exista, o
Bluetooth será desconectado e caso contrário, um alerta informará que não há uma conexão com
Bluetooth.
Figura 5.21. Notificação apresentada ao tentar desconectar quando não há conexão estabelecida.
Passadas essas etapas da conectividade Bluetooth, seguimos para os botões “Ligar” e

“Desligar”, responsáveis pelo envio de um dado serial que representa uma das solicitações, de
acionamento ou desligamento, enviada ao clicar para o Arduino que faz o controle da lâmpada.
Ainda assim, caso a conexão com o Arduino não tenha sido estabelecida, temos uma mensagem
de erro para sinalizar a questão.
150
Figura 5.22. Blocos para envio de solicitação para acionar ("A") e desligar ("D") a lâmpada.
Até aqui temos todo o mecanismo de funcionamento para que a conexão do Bluetooth e
entre os componentes do sistema seja estabelecida e para que as solicitações sejam enviadas
ao Arduino.
Para que tenhamos agora a questão da realimentação efetiva é necessário criarmos uma
função que seja responsável por receber os dados que o microcontrolador, que verifica
constantemente a resposta da ação que está sendo executada,de modo a apresenta-los em tela.
Isso será feito pelo próximo conjunto de dados que será mostrado.
Figura 5.23. Blocos responsáveis por verificar e receber informações, via Bluetooth, para seu
display na tela do aplicativo desenvolvido.
Nessa estrutura, a cada “Clock1” é feita uma verificação de se o Bluetooth está conectado
e, caso a condição seja atendida, o label “AGUARDANDO” terá seu texto em tela alterado de
“AGUARDANDO...” para aquele recebido via Bluetooth.
151
O valor de “Clock1” estava pré-estabelecido como 1000 (unidade em milisegundos), na
aba Designer em “TimerInterval”. A cada passagem desse tempo, verifica-se a conexão
Bluetooth e, estando conectado, faz-se uma busca por bytes disponíveis a serem recebidos via
Bluetooth. Esses bytes são representados pelas mensagens enviadas pelo Arduino: “Ligado “
e “Desligado “.
Montados todos esses blocos estamos prontos para realizar a build e utilizar o aplicativo
juntamente com o programa carregado na placa do microcontrolador finalizando nosso primeiro
método de integração entre Arduino e App Inventor!
5.4. Comunicação via Ethernet e roteador
A Ethernet, padronizada como sendo a norma da IEEE 802.3, é uma arquitetura de

interconexão para redes locais baseada no envio de pacotes, sendo esses pacotes de dados
transmitidos por meio de sinais elétricos utilizando-se de cabos. Como o Arduino Uno não possui
comunicação com rede por meio de Ethernet é necessário a utilização de um shield para tornar
isso possível.
Como a intensão do sistema a ser elaborado é a comunicação sem fio entre um
microcontrolador e um smartphone Android, utilizaremos também um roteador. Sem entrar em
muitos detalhes do funcionamento das redes8, temos que o Arduino será conectado via Ethernet
com o roteador e a comunicação com o smartphone será dava via rede sem fio Wi-fi.
O sistema funcionará numa arquitetura de cliente-servidor, onde o Arduino é o responsável
por prover recursos de rede, pelo recebimento de requisições, ação subsequente ao solicitado e
envio de resposta (processo servidor), e o dispositivo Android é o responsável pelo envio de
requisições, espera e recebimento de respostas, utilização dos recursos de rede providos e
interação com usuário do mesmo (processo cliente).
SHIELD ETHERNET
A versão mais atual do shield (Ethernet Shield 2) é baseada no Wiznet W55009 e prove
uma rede capaz de utilizar os protocolos de comunicação UDP (mais rápido) e TCP (mais
confiável no que diz respeito a transmissão de dados).
8
O conteúdo e estudo sobre redes de computadores é bastante extenso e tomaria um tempo que é desnecessário no momento para
o propósito desse material.

9O chip W5500 é um controlador de Ethernet que permite uma conexão mais fácil com a internet sendo utilizada por sistemas
embarcados tal como o Arduino.
152
Para a conexão com a rede incluiremos na programação o cabeçalho “Ethernet.h” (ou
“Ethernet2.h, para a versão atual), da biblioteca “Ethernet” e utilizaremos funções associadas.
Além disso, incluiremos um cabeçalho chamado “SPI.h” devido a comunicação entre o shield e
o microcontrolador em si, que utiliza um barramento da placa denominado SPI (Serial Peripheral
Interface).
O SPI é um protocolo que permite a comunicação entre o microcontrolador e outros
componentes como, nesse caso, o shield Ethernet. O barramento ocupa os pinos de 10 a 13 do
Uno, não devendo os mesmos serem utilizados para outra finalidade nessa situação. Além disso,
o shield possui um slot para microSD, utilizando o pino 4 e compartilhando o barramento com o
Arduino sendo outro que não deve ser utilizado quando um estiver acoplado.
Figura 5.24. Shields Ethernet versão 1 (à esquerda) e 2 (à direita).
Figura 5.25. Esquema do shield Ethernet, indicando os pinos referentes ao SPI (10, 11, 12 e 13) e ao
cartão SD (microSD, em sua versão atual).
153
MONTAGEM DO SISTEMA
Os seguintes componentes são necessários para a montagem desse sistema:
 Arduino Uno com cabo USB 2.0;
 Fonte 12V chaveada 100-240VAC para Arduino;
 Módulo relé 5V de um canal;
 Ethernet Shield W5100/W5500;
 Roteador Wireless N 5dbi 150mbps (por exemplo);
 cabo UTP com plug RJ-45;
 Um Resistor de 10kΩ;
 Um LDR;
 Jumpers (macho-macho);
 Protoboard;
O Arduino acoplado ao shield pode ser conectado de duas maneiras ao roteador: pela
porta WAN ou por uma das portas LAN.
A porta WAN (Wide Area Network) diz respeito à configuração de uma rede externa
cobrindo um grande espaço físico. Normalmente é utilizada como referência à rede da internet,
por ser utilizada para conectar o cabo que permite acesso a mesma. Sendo assim, caso o
Arduino seja conectado nessa porta, teremos o fechamento de uma rede onde todos os
dispositivos que se conectem a ela estarão conectando-se ao microcontrolador e entre si.
Quando conectado à porta LAN (Local Area Network), os demais dispositivos que se
conectam pelas demais portas LAN ou pelo Wi-fi estarão conectados entre si e com a internet
(caso um cabo que permita esse acesso esteja conectado na porta WAN).
154
Porta WAN Portas LAN
Figura 5.26. Roteador com destaque eu suas portas LAN e porta WAN.
As configurações em si do roteador para que ele funcione adequadamente dependem de

seu modelo e podem ser realizadas com uso de seu manual físico ou digital do fabricante. Mas
por comodidade do teste, utilizar um roteador já ativo e configurado de um ambiente residencial,
por exemplo, não surte nenhum efeito adverso no funcionamento da rede e dos equipamentos
já conectados à ela.
Feita a conexão do roteador com o shield Ethernet acoplado ao Arduino utilizando o cabo
com plug RJ-45 e energizando-os com suas respectivas fontes de alimentação, o restante da
montagem é como se segue na próxima figura (bastante semelhante a montagem do projeto
anterior).
Figura 5.27. Acoplamento do shield com o microcontrolador.
155
RJ-45
Figura 5.28. Montagem do sistema, excetuando-se a conexão ao roteador.
Para que o Arduino tenha acesso a rede e se comunique com outros dispositivos através
do shield Ethernet é necessário, também, que o microcontrolador também tenha um endereço
de IP (Internet Protocol) e um MAC (Media Access Control), que serão declarados em sua
programação.
Com relação ao IP, é necessário verificar um endereço que seja pertencente e esteja
disponível para uso na rede. Para podermos identificar um endereço disponível, podemos utilizar
um dispositivo já conectado à rede, verificar seu IPv4/6 (ip do dispositivo) e o gateway padrão (ip
do roteador) e, a partir disso, alterando-se o byte menos significativo do IP do dispositivo teremos
um novo endereço pertencente a rede.
Utilizando um computador macOS/OS X, devemos clicar no ícone da maçã e em
“Preferências do Sistema...”. Na sequência, na janela de configurações, devemos selecionar a
156
opção “Rede” e, na janela que se abrir, teremos a informação do ip da máquina. Ali, clicar em
Avançado nos dá a possibilidade de verificar o ip do roteador na aba de “TCP/IP”.
Através de um sistema Linux podemos utilizar, por exemplo, o comando “ifconfig”, em seu
terminal. No prompt de comando do Windows, que podemos acessar pressionando as teclas
“Windows+R” através do comando “cmd” (sem aspas), “ipconfig” é a palavra chave para ter
acesso as informações necessárias.
Figura 5.29. Resultado obtido a partir do uso do comando ipconfig no prompt de comando do
Windows.
Na figura acima, IPv4: 192.168.0.102 e gateway: 192.168.0.1. Sendo assim, podemos

escolher um IP do tipo 192.168.0.x, sendo x um valor entre 0 e 255 (valores representados por
um byte). Como outros dispositivos podem já estar conectados à rede, é recomendado a escolha
de um valor mais elevado como, por exemplo, 120, 200 ou 203, evitando-se um conflito na
mesma.
Finalizada essa configuração inicial podemos realizar todas as questões de cliente-
servidor na qual o sistema é baseado. Sendo assim, ao realizar uma solicitação por meio do
aplicativo desenvolvido para tal sistema, a mesma será enviada via Wi-Fi ao roteador que, por
sua vez, transmitirá os dados de solicitação ao Arduino. O microcontrolador irá dessa forma
verificar o que foi solicitado e realizar uma ação de acionamento ou desligamento da lâmpada
além de fazer o trabalho da realimentação efetiva verificando se a ação decorrente do que foi
solicitado está de acordo com o esperado ou não. A partir daí uma resposta será enviada ao
dispositivo Android e a apresentará na tela para o usuário.
Figura 5.30. Esquema de funcionamento do sistema.
157
Além dos cabeçalhos “Ethernet.h” e “SPI.h”, utilizaremos “String.h”, devido as
manipulações que serão feitas com esse tipo de dado. Iniciaremos, também, o datatype (tipo de
dado) “byte” para iniciar os vetores das variáveis que representarão o IP e o MAC do dispositivo.
Como já foi apresentado, o Arduino está envolvido no processo de servidor. Assim, o
mesmo é responsável por fornecer os recursos de rede necessários para à comunicação com o
aplicativo. Será então necessário o uso da função EthernetServer(), pela qual é criado servidor
que escuta por conexões através de uma porta de serviço específica que é fornecida (como uma
porta aberta na qual os interessados podem entrar e interagir com o anfitrião).
#include <SPI.h> //cabeçalho devido ao uso do shield
#include <String.h> //cabeçalho para o uso de variáveis tipo string
#include <Ethernet.h> //para o shield ethernet primeira versão
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x9B, 0x36 }; // Endereço Mac
byte ip[] = { 192, 168, 0, 178 }; //Endereço de Ip disponivel na Rede
EthernetServer server(8090); // Porta de serviço
const int rele = 8; // Pino onde o modulo de rele estah ligado

const int analogPin = 2; //pino de leitura analogica do LDR
boolean status_lamp = false; // Variável para o status da lampada
String readString = String(30); //string para buscar dados de endereço

int resposta;
Feitas essas configurações iniciais e a inicialização das demais variáveis, partimos para
o setup(), onde teremos uma nova linha iniciando a função Eterneth.begin(), que inicializa a
biblioteca Ethernet e configurações de rede pegando como argumentos os valores de MAC e IP
estipulados no início do código.
Demais estruturas e funções referentes ao Ethernet, encontradas em loop(), serão
rapidamente explicadas no código bem como a criação do web server, responsável por permitir
o Arduino a responder as requisições HTTP (Hypertext Transfer Protocol) recebidas do
dispositivo Android. Essas respostas são referentes aos quatro quadrantes, tal como na
comunicação via Bluetooth, porém, as respostas serão apenas repassadas após recebimento de
requisição e resposta à mesma (não faremos o envio intermitente de resposta). Veja:
158
void setup() {
Ethernet.begin(mac, ip); // Inicia o Ethernet
pinMode(rele, OUTPUT); // Define o pino como saída
Serial.begin(9600); // Inicia a comunicação Serial
digitalWrite(rele, HIGH); //mantem lampada inicialmente desligada

}
}
void loop() {
DetectaLuzTempo();
//cria cliente que pode se conectar a um IP e porta especifico

EthernetClient client = server.available();
/*se o servidor estiver disponivel
uma conexão com o cliente serah feita
e enquanto ela estiver disponivel as demais
estruturas rodaram ateh ser solicitada a
parada da comunicacao (ao final do codigo)*/
if (client){
while (client.connected()){ //conecta o cliente
if (client.available()){ //verifica dados disponiveis
char c = client.read(); //le os dados disponiveis
//caractere por caractere vindo do HTTP, ou seja,
//as mensagens transferidas pela porta especificada ao
//endereco do arduino
if (readString.length() < 30) //palavra menor do que maximo
{
// armazena os caracteres para string
readString += (c);
}
// Se o pedido HTTP terminou
if (c == '\n'){
// vamos verificar se a lampada deve ser ligado
// Se a string possui o texto LigarLampada
if(readString.indexOf("LigarLampada")>=0)
{
digitalWrite(rele, LOW); //comando de acionamento da
//lampada
159
status_lamp = true; //o pedido de acionamento foi
//realizado
delay(500);
}
// Se a string possui o texto DesligarLampada
if(readString.indexOf("DesligarLampada")>=0)
{
digitalWrite(rele, HIGH); //comando de desligar a lampada
status_lamp = false; //pedido de desligar foi realizado
delay(500);
}
/* dados HTML de saída começando com um cabeçalho padrão
* temos aqui a montagem de um web server simples
* que mostra as mesmas mensagens de resposta
* que são apresentadas no aplicativo desenvolvido */
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println();
client.print("<font size='20'>");
resposta = analogRead(analogPin );
/* as estruturas a seguir fazem uso do booleano para

* a realimentacao efetiva observando a questao dos
* 4 quadrantes */
if (status_lamp){ //para 2 quadrantes de acionamento
if (resposta > ambiente)
client.println("ComandoLigar LuzLigada");
else
client.println("ComandoLigar LuzDesligada");
}
else if(status_lamp == false){ //para 2 quadrantes de

//desligamento
if (resposta <= ambiente)
client.println("ComandoDesligar LuzDesligada");
else
client.println("ComandoDesligar LuzLigada");
}
readString="";//limpa string para a próxima leitura
client.stop();// parar cliente
}
}
}}}
160
Devido a estrutura de mensagem utilizada, verificaremos inicialmente o tamanho da string
lida através da função readString.length() e sendo esse tamanho dentro do estipulado
faremos a leitura dos dados recebidos por meio de readString armazenando-a em “c”.
Por padrão, um vetor de char será terminado com um caractere do tipo “\n”. Dessa
maneira, ao observar esse caractere, como feito na programação, saberemos que o dado
enviado foi totalmente recebido e podemos prosseguir com o programa.
A função “readString.indexOf” verifica se a solicitação HTTP enviada pelo aplicativo
contém o texto “LigarLampada” ou “DesligarLampada” e, sendo localizada uma delas, uma ação
será tomada e um booleano (status_lamp) terá seu valor de acordo com o que foi solicitado.
No programa, vemos o uso desse booleano na estrutura condicional de uma maneira
interessante (o mesmo ocorre mais ao início de loop() com “client”). No caso, quando desejamos
verificar se o valor é verdadeiro, podemos utilizar 3 formas diferentes que, utilizando a estrutura
no qual o booleano foi aplicado, são:
if(status_lamp == TRUE), if(status_lamp == 1) ou if(status_lamp).
Quando status_lamp é verdadeiro, ou seja, o comando enviado para o relé foi de
acionamento, entraremos em um if-loop que verifica os quadrantes voltados para essa condição
inicial:
 Solicitação de acionamento, lâmpada ligada;
 Solicitação de acionamento, lâmpada desligada.
E, no caso de status_lamp falso, vamos para a estrutura restantes para fechar os quatro
quadrantes do funcionamento em realimentação efetiva:
 Solicitação de desligamento, lâmpada desligada;
 Solicitação de desligamento, lâmpada ligada.
Daí, as mensagens utilizando “cliente.println” são aquelas enviadas como resposta ao
dispositivo Android como resposta.
A programação parece extensa, devido a introdução e uso da biblioteca Ethernet, mas
seu entendimento é relativamente simples, seguindo uma sequência de fácil explicação:
 Fazemos a inclusão dos cabeçalhos necessários;
 Estabelecemos o IP, MAC e porta de serviço;
 Inicializamos as variáveis que serão utilizadas para os pinos, leitura de dados,
ações, realimentação e leitura do ambiente;
 Iniciamos as comunicações serial, Ethernet e o pino digital e fazemos a verificação
inicial de luminosidade;
 Verificamos o tempo para releitura de luminosidade;
161
 Iniciamos a comunicação com os clientes, verificamos disponibilidade de dados
para leitura, lemos e armazenamos os mesmos;
 Verificamos a mensagem de interesse recebida nesses dados
 Realizamos ação de acordo com o recebido utilizando um web server
 Encerra comunicação com cliente.
Para finalizar, não devemos nos esquecer da declaração da função e seu script.


else{
ambiente=0;
}
}
}
}
DESENVOLVIMENTO DO APLICATIVO
Para o Designer do aplicativo teremos uma apresentação mais simples. Os botões
utilizados são para o controle da lâmpada, sendo a conexão com a rede feita pelo próprio
dispositivo de Wi-Fi do celular. A tabela com os componentes utilizados e suas modificações será
apresentada a seguir.
162
Tabela 5.2. Componentes para o projeto de comunicação via Ethenet e roteador.
Inicia com BackgroundImage Network.jpg
Screen1
projeto Icon wificon.jpg
Width Fill parent
FontSize 25
FontBold marcar
LIGAR (Button) User Interface Width Fill parent
Shape Rounded
Text LIGAR
BackgroundColor Red
FontSize 25
FontBold marcar
DESLIGAR (Button) User Interface
Width Fill parent
Shape Rounded
Text DESLIGAR
BackgroundColor none
FontSize 25
Label_status (Label) User Interface
Text STATUS
TextColor Yellow
BackgroundColor none
FontSize 25
Label_resultado (Label) User Interface
Text Aguardando...
TextColor Cyan
Web1 Connectivity - -
Notifier1 User Interface - -
As imagens utilizadas para plano de fundo do aplicativo e ícone do mesmo (para quando
instalado no dispositivo Android) estão na figura a seguir.
163
Figura 5.31. Plano de fundo do aplicativo à esquerda e ícone do aplicativo, à direita.
Feita a montagem, o aplicativo terá o seguinte aspecto (ver figura abaixo):
Figura 5.32. Layout no Viewer após montagem dos componentes.
164
Partindo agora para a aba Blocks faremos a revisão bloco a bloco.
Figura 5.33. Bloco com chamada de URL, utilizada para verificar conexão do sistema.
Ao inicializar o aplicativo estabeleceremos a URL10 (Uniform Resource Locator) desejada,

que nada mais é que um endereço capaz de localizar os recursos de desejamos utilizar da rede.
No caso, essa URL é referente ao IP e porta que desejamos acessar do Arduino e, indicado esse
valor pelo “set Web1.Url” faremos uma chamada dessa URL, pelo “call Web1.Get”, utilizado
basicamente para verificar a conexão.
Independente do momento, sendo na inicialização do programa ou ao realizar uma
solicitação por meio dos botões, caso o aplicativo não esteja conectado à rede na qual se
encontra o Arduino, não será possível obter uma resposta à partir da URL chamado. Isso
configura um erro identificado pelo número “1101” e, para que fique claro ao usuário seu
significado, podemos construir um bloco de notificação, como mostrado na próxima figura.
Figura 5.34. Bloco com dialogo de escolha para erro 1101, obtido quando não se obter resposta da
chamada da URL.
10 Se refere a um endereço de rede no qual algum recurso de interesse pode ser localizado, como um
arquivo texto, dispositivo de E/S, dentre outros. A representação completa de uma URL é da forma
“protocolo://domínio:porta/caminho/recurso?query_string#fragmento”. No aplicativo que está sendo criado,
temos URL’S que vão até a “porta” e, também, ao “caminho”.
165
A estrutura condicional é referente a um erro que ocorre e é mostrado na tela do
dispositivo, por isso à utilizamos em “Screen1”. Em seu interior, utilizamos a estrutura “if” para
verificar o número do erro obtindo e, sendo ele “1101”, chamamos um diálogo de notificação para
escolha de uma opção.
Figura 5.35. Caixa de dialogo de notificação quando o aplicativo não está conectado à rede do
Arduino.
Dependendo da opção selecionada, teremos uma ação correspondente: “Continuar sem

WIFI” mostra um alerta solicitando a conexão e “Fechar App”, fecha o aplicativo.
Figura 5.36. Bloco de ações após escolha de opção na caixa de notificação.
Quando a conexão está estabelecida e a rede está funcionando normalmente, os blocos

relativos aos botões podem funcionar adequadamente. Cada um deles é responsável de fazer a
chamada de uma URL ao click, com dados de IP, porta e a ação à qual ele se refere. O Arduino
receberá essa requisição HTTP e fará as execuções das devidas estruturas conforme
apresentado anteriormente em seu código de programação.
166
Figura 5.37. Blocos relativos aos botões de solicitação de acionamento ("LIGAR") e desligamento
("DESLIGAR") da lâmpada.
Das requisições feitas, o Arduino enviará uma resposta e a mesma será apresentada na
tela do dispositivo Android quando recebido. Além disso, as solicitações e respostas podem ser
realizadas e visualizadas pelo browser, sabendo-se as URL’s para as solicitações (as mesmas
descritas pelos botões do aplicativo).
O aplicativo receberá os textos de resposta através do “Web1.GotText” e para a
interpretação dessas respostas recebidas temos a peça “contains text” que compara esse valor
com um dos esperados para que possa apresentar todas as respostas dos 4 quadrantes na tela.
Figura 5.38. Bloco com as interpretações das respostas recebidas para apresentação das mesmas
em tela.
167
Figura 5.39. Respostas possíveis apresentadas em tela.
Figura 5.40. Respostas no browser dados os comandos que o Arduino responderia.
Criado esses blocos, temos todo o necessário da programação para enviar as solicitações
e receber e tratar o texto de resposta.
5.5. Comunicação via GSM
O Sistema Global para Comunicações Móveis (GSM) é um padrão de comunicação por

sinal de rádio bastante difundindo e utilizado por celulares.
Para que possamos realizar a troca de dados entre o Arduino e o dispositivo Android
utilizaremos o Shield GSM/GPRS com módulo SIM900, um módulo quad-band. O módulo realiza
168
controle através de comandos AT11 sendo capaz de trabalhar com SMS, fazer up/download de
dados para um servidor web e enviar sinais via alto-falante e fone de ouvido ou realizar gravação
de áudio, fazendo com que o Arduino tenha as funcionalidades de um telefone celular.
A troca de dados no sistema a ser montado será via SMS.
SHIELD GSM/GPRS SIM900

Além dos recursos de comunicação apresentados, o shield ainda permite o uso dos
elementos comuns do Arduino, com o módulo possuindo 12 GPIO’s (entradas e saídades de
propósito geral), 2 PWM’s e um ADC (conversor analógico digital).
A porta serial do shield (TX e RX do módulo) faz, quando acoplado, conexão com os pinos
2 e 3 do Arduino e, dessa forma, para a transferência de dados utilizaremos a biblioteca
SoftwareSerial. Além disso, utilizaremos uma biblioteca complementar a existente e oferecida
pelo IDE para a programação referente ao sheild SIM900 para o seu funcionamento correto, o
que nos faz aproveitar o momento para introduzir a questão do uso e da funcionalidade de
bibliotecas de terceiros.
Antes de acoplar o shield GSM ao Arduino, é necessário possuirmos cartão SIM
desbloqueado de alguma operadora para que possamos fazer interface com uma rede de celular
e, de fato, comunicar o dispositivo Android ao microcontrolador do sistema a ser elaborado.
Além disso, assim como no sistema de comunicação via Ethernet com roteador,
utilizaremos uma fonte externa na tomada do Arduino devido ao shield poder consumir uma maior
quantidade de corrente atingindo picos de até 2A.
11 Comandos AT são utilizados para controlar MODEMs. AT é a abreviação de atenção. Estes comandos vem dos Hayes
commands. Dispositivos que envolvem comunicação entre maquinas precisam desses comando para interagir com um computador,
no caso, o arduino. Os mesmos, quando utilizados no shield podem ser usados para acessar informações e serviços do tipo SMS,
MMS, fax e de dados e voz ligados a uma rede móvel.
169
Figura 5.41. Visão superior do Shield GSM/GPRS SIM900.
Figura 5.42. Visão da parte inferior do Shield GSM mostrando o local (parte cinza) onde devemos
encaixar o cartão SIM.
MONTAGEM DO SISTEMA
O sistema semelhante ao da montagem do ultimo realizado utilizando Ethernet,
modificaremos apenas o shield nesse caso. Utilizaremos:
 Arduino Uno com cabo USB 2.0;
 Fonte 12V chaveada 100-240VAC para Arduino;
 Módulo relé 5V de um canal;
 GSM/GPRS Shield SIM900;
 Cartão SIM desbloqueado para uso no shield;
170
 Um Resistor de 10kΩ;
 Um LDR;
 Jumpers (macho-macho);
 Protoboard;
As conexões são como se seguem e o shield não foi representado na imagem, mas os
jumpers devem ser ligados no mesmo.
Figura 5.43. Montagem do sistema. Shield GSM/GPRS SIM900 não representado.
171
Um problema que poderíamos nos deparar para o funcionamento do sistema seria com
relação ao bloqueio PIN (Personal Identification Number). Os cartões que usualmente
compramos de uma operadora qualquer não possuem bloqueio por PIN, mas caso se depare
com uma situação do tipo, onde o sistema não funcione mesmo que esteja tudo aparentemente
correto na montagem e códigos do Arduino e App Inventor, vale apena conectar o SIM do shield
num dispositivo Android e, nas opções de segurança, buscar por configurações de bloqueio do
mesmo e desbloquea-lo.
Estando agora nas condições de configuração do cartão SIM, montagem e programação
corretas o sistema funcionará de uma maneira simples. Informaremos ao aplicativo o número de
telefone referente ao Arduino e o salvaremos. Essa inicialização é feita para evitar que outras
pessoas que, por alguma razão, tenham acesso ao aplicativo, mas não estejam autorizadas a
utilizar o sistema tenham isso facilitado.
Informado o número, podemos agora fazer o envio de mensagens ao microcontrolador
que, ao recebe-la, verificará a solicitação enviando um comando ao relé. O LDR fará seu papel
verificando o status do comando para a questão da realimentação efetiva e uma mensagem de
resposta será repassada ao Arduino que, por sua vez, apresentará uma mensagem em tela sobre
a solicitação. O código das mensagens recebidas podem também ser verificados pela caixa de
mensagens do dispositivo Android, tendo em vista que a leitura das respostas é feita por ela.
Precisamos fazer o download da biblioteca que envolve os usos e funcionalidades do
shield. A mesma pode sem localizada no site GitHub, disponibilizada por “MarcoMartins” em:
https://github.com/MarcoMartines/GSM-GPRS-GPS-Shield.
172
Figura 5.44. Recorte da página web onde podemos localizar e fazer o download da biblioteca
necessária para uso do shield.
Ao acessar a página, devemos clicar em “Clone or download”, como indicado na imagem

acima e selecionar a opção “Download ZIP” na janela que será apresentada.
Recordando o processo de inclusão da biblioteca, devemos abrir o IDE e seguir o caminho
Sketch > Incluir biblioteca > Adicionar biblioteca .ZIP, localizar o arquivo baixado e seleciona-lo.
Feito isso, podemos seguir para o código em si.
Faremos, então, a inclusão dos cabeçalhos necessários e inicialização de algumas
variáveis. Além das conhecidas para luminosidade e pinos, utilizaremos algumas do tipo char
para localização da mensagem, leitura do número que enviou a mesma e seu conteúdo, sendo
as duas últimas variáveis vetores char.
173
#include <SPI.h>
#include <String.h>
#include <SoftwareSerial.h> //para comunicacao serial do shield
#include "SIM900.h" //para utilizar o módulo GSM
//para funcoes do Arduino IDE para administrar mensagens

#include "sms.h"
SMSGSM sms;
char sms_position; //posição da mensagem no cartão

char phone_number[20]; //armazenamento do numero do telefone que
//enviou mensagem (ex: +553412345678)
char sms_text[100]; //tamanho possível para mensagem
const int rele = 8;

const int analogPin = 2;
boolean status_lamp = false;
int ambiente = 0;
int LDR = 0;
int resposta;
Como no comentário do próprio código, “phone_number[20]” é um vetor de caracteres

que aceita até 20 elementos, tamanho suficiente para agregar todos os dígitos de um número de
telefone que incluem “+”, o código de discagem do país e o código de discagem da região. Um
número de São Paulo – SP, por exemplo, teria um número do tipo “+55 11 912345678” (sem
espaços).
O vetor “sms_text[100]”, embora aceite essa grande quantidade de caracteres, receberá
valores curtos e fixos vindos do aplicativo à partir da solicitação realizada. Caso seja de interesse
essas mensagens podem ser modificadas para dificultar ainda mais a questão de acesso e
solicitações indesejadas, bem como poderíamos ter modificado o tamanho do vetor.
As mensagens que serão recebidas são: “ON”, quando da solicitação de acionamento, e
“OFF”, para desligar a lâmpada.
Seguiremos para o setup(), onde iniciaremos a comunicação serial e gsm, iniciaremos o
pino do relé no modo de saída de dados e faremos a verificação inicial da luminosidade do
ambiente onde o sistema está instalado.
Embora a taxa de transmissão de dados gsm tenha sido escolhida como de 9600bits/s,
essa taxa pode ter uma velocidade menor de forma que funcionará bem.
174
void setup() {
Serial.begin(9600);
gsm.begin(9600); //inicia a conexão GSM
pinMode(rele, OUTPUT);
digitalWrite(rele, HIGH);
while (millis() < 5000)

{
}
Partindo agora para o loop(), temos a função para verificação periódica da luminosidade
e iniciamos o tratamento de mensagens a serem recebidas.
void loop() {
DetectaLuzTempo();
/*verifica se existe mensagem não lida em alguma posição de

armazenamento do cartão SIM */
sms_position=sms.IsSMSPresent(SMS_UNREAD);
if (sms_position) //se houver mensagem...

{
//pega os dados da mensagem
sms.GetSMS(sms_position, phone_number, 20, sms_text, 100);
//Serial.println(sms_text); //para ver mensagem no serial monitor
Uma verificação da presença de mensagens não lidas é feita por

“sms.IsSMSPresent(SMS_UNREAD)” e quando uma é localizada, seu valor é salvo em
“sms_position”.
Pela condição de existência de um valor de sms_position, será chamada a função
“GetSMS” que tem como argumentos:
175
 o byte que representa a posição da mensagem na memória do cartão SIM;
 os caracteres para o número de telefone;
 o valor máximo de caracteres que o número de telefone pode ter;
 os caracteres que compõem a mensagem;
 o valor máximo de caracteres que ela pode ter.
Caso seja de interesse, podemos descomentar a linha do último trecho de código

apresentado afim de mostrar no monitor serial a mensagem recebida.
//se a mensagem vinda do APP for 'ON'

if(strcmp(sms_text,"ON")==0){
Serial.println("Requisição de acionamento recebida");
digitalWrite(rele, LOW); //envia nivel baixo para porta digital
status_lamp = true;
delay(200);
}
//se a mensagem vinda do APP for 'OFF'

else if(strcmp(sms_text,"OFF")==0){
Serial.println("Requisição de desligamento recebida");
digitalWrite(rele, HIGH); //envia nivel alto para porta digital
status_lamp = false;
delay(200);
}
Acima, utilizamos dentro das estruturas condicionais a função de string “strcmp”, que
promove a comparação de um valor de variável com outro valor de interesse e, caso essa
comparação seja verdadeira, retorna o valor 0. No caso, a mensagem recebida e armazenada
em “sms_text” sera comparada com “ON” e com “OFF”, caso a comparação inicial não seja
atendida como verdadeira.
Atendida a condição um texto será enviado ao monitor serial informando a solicitação
(apenas por confirmação, a linha pode ser transformada em comentário) e um sinal de baixa ou
de alta enviado ao pino do relé para ligar ou desligar a lâmpada, respectivamente. Além disso,
teremos a atribuição de valor para “status_lamp” que, conforme no projeto de comunicação
Ethernet, será utilizado para a verificação dos quadrantes.
176
if(status_lamp){
Serial.println("Acionamento realizado");
sms.SendSMS(phone_number,"ONACK"); //lampada acionada
}
else if(resposta <= ambiente){
Serial.println("Falha no acionamento");
sms.SendSMS(phone_number,"ONnotACK"); //lampada não acionada
}
}
else if(status_lamp == false){

if(resposta <= ambiente){
Serial.println("Desligamento realizado");
sms.SendSMS(phone_number,"OFFACK"); //lâmpada desligada
}
else if(resposta > ambiente){
Serial.println("Falha no desligamento");
sms.SendSMS(phone_number,"OFFnotACK"); //falha ao desligar
}
}
}
del_sms();
Temos na sequência a leitura de dados do pino analógico no qual o LDR está conectado,
comparação do valor de resposta com o valor ambiente e verificado o obtido com “status_lamp”.
Através de “sms.SendSMS” será enviada uma resposta proporcional ao número que enviou a
solicitação de acionar ou desligar a lâmpada, número esse que foi armazenado em
“phone_number”.
Antes de finalizar o loop(), faremos uso de uma função nova chamada “del_sms()”,
responsável por deletar mensagens já lidas.
Na parte final do programa, temos as duas funções criadas por nós e utilizadas. Vamos
verificar a parte do código referente a função de deleção.
177


luminosidade após a inicial
else{
ambiente=0;
}
}
}
}
void del_sms(){
Serial.println("deleting old sms");
for (int i=0; i<10; i++){ //verifica ateh 10 mensagens
int msg=sms.IsSMSPresent(SMS_READ); //busca mensagens lidas
if (msg!=0){ //encontrando mensagem lida…
Serial.println("Old SMS found ");
if (sms.DeleteSMS(msg)==1) //sendo a mensagem deletada
Serial.println("Old SMS deleted ");
}
else
Serial.println("No SMS to be deleted ");
}
}
Os comandos para envio de mensagens ao monitor serial são, mais uma vez para que
tenhamos uma melhor visão dos processos acontecendo. Como o cartão SIM tem um espaço
178
bastante limitado para armazenamento das mensagens que recebe e não libera esse espaço por
si só para o recebimento de novas, uma função que faça esse papel é importante para que o
sistema não para de responder.
Sendo assim, utilizamos um for-loop no qual verificaremos, por 10 vezes, a existência de
mensagens lidas utilizando “sms.IsSMSPresent(SMS_READ)”. Encontrada uma mensagem já
lida, aplicaremos “sms.DeleteSMS()” para apaga-la.
Temos agora todo o necessário para que o Arduino receba as mensagens advindas do
aplicativo e responda-as adequadamente.
DESENVOLVIMENTO DO APLICATIVO
Como cada cartão SIM possui um número diferente para discagem, uma maneira de
facilitar a comunicação, de modo que não seja necessária a compilação do código do Arduino a
cada montagem com SIM diferente, é a criação de um campo para que possamos digitar o
número de contato e salvar seu valor.
Faremos isso de um modo simples, de forma que cada inicialização do aplicativo solicite
o número de contato do Arduino. Mas é possível salvar de maneira que o aplicativo tenha valores
atribuídos à variável quando for inicializado novamente (explore as possibilidades!).
Alguns componentes de alinhamento foram utilizados para o layout visando estética
apenas e, dessa vez, apenas escolhemos um ícone para o aplicativo (sem upload de imagem de
fundo). A imagem do ícone pode ser vista na próxima figura.
Figura 5.45. Imagem para icone do aplicativo de comunicação via GSM.
Com relação ao Designer sua montagem é como se segue:
179
Tabela 5.3. Componentes para o projeto de comunicação via GSM.
Inicia com BackgroundColor Dark Gray
Screen1
projeto Icon sms.png
VerticalArrangement1 Layout Height 10 pixels
FontBold marcar
DIGITE O NÚMERO
Label1 User Interface Text
DO ARDUINO
TextColor Cyan
TEXTNUMBER Width Fill parent
User Interface
(TextBox) NumbersOnly marcar
FontBold marcar
USARNUMERO (Button) User Interface Text USAR NÚMERO
FontBold marcar
Width Fill parent
LIGAR (Button) User Interface
Shape rouded
Text LIGAR
VerticalArrangement5 Layout Width 10 pixels
BackgroundColor Red
FontBold marcar
Width Fill parent
DESLIGAR (Button) User Interface
Shape rouded
Text DESLIGAR
FontSize 20
Label2 User Interface Text STATUS
TextColor yellow
Text AGUARDANDO...
STATUS (Label) User Interface
TextColor Cyan
Notifier1 User Interface - -
Texting1 Social - -
Texting2 Social - -
180
O aplicativo terá o seguinte aspecto no painel Viewer:
Figura 5.46. Layout no Viewer após inclusão dos componentes.
Seguindo para a aba BLOCKS, começaremos a programação com a inicialização de duas

variáveis globais de texto. Uma referente ao número de telefone do Arduino a ser salvo e outra,
para armazenar as respostas obtidas do mesmo (nomes das variáveis são escritos após escolha
e seleção dos blocos para o viewer).
Figura 5.47. Variáveis iniciadas para armazenamento de informações repassadas ao aplicativo. O

nome da variável é determinada pelo usuário.
Prosseguiremos com um bloco que trate o que será escrito no campo de texto criado e o
que ocorrerá ao clicarmos no botão para “USAR NÚMERO”.
Como já mostrado na Tab. 3.3, marcamos uma opção do campo de texto que o configura
para que apenas um teclado numérico apareça quando clicarmos no mesmo para escrever uma
181
informação. Isso facilita a digitação quando apenas uma informação numérica é solicitada e evita
que o usuário clique em valores fora dos de interesse.
Além disso, um telefone celular tem um requisito mínimo de números. No código do
aplicativo, diferente do apresentado ao falarmos da programação do Arduino, apresentamos uma
estrutura de número sem o “+55”, considerando que o uso será dado dentro do país, facilitando
o entendimento dos usuários.
Caso um telefone não seja inserido no campo de texto ou o mesmo tenha uma quantidade
de números diferente da esperada um diálogo de escolha de notificação será apresentada em
tela (Notifier1.ShowChooseDialog) informando o formato correto a ser utilizado, que consiste no
digito “0”, associado ao código de área do cartão SIM arduino e seguido pelo seu número
propriamente dito, o que totaliza 12 dígitos (ex.: 0 11 9 12345678, sem os espaços).
Figura 5.48. Bloco referente às ações a serem executadas quando o botão "USARNUMERO" for
precionado dependendo da caixa de texto numérico.
No título (title) de Notifier1 foram utilizados diversos “\t”, artifício denominado escape
sequence12, para se distanciar da margem (tal como ao usar a tecla TAB) da caixa de notificação.
É uma estrutura com único intuito para o design da caixa.
12 Uma sequencia de escape (escape sequence) é uma combinação de caracteres utilizados para um dado tipo de controle que
permite o envio de caracteres de controle não gráficos – como um espaço ou salto de linha – para dispositivos de impressão tal como
a saída de tela em um computador ou celular.
182
Figura 5.49. Tela do aplicativo quando selecionado o campo de texto para digitação do telefone e
caixa de notificação quando o número não segue o padrão.
Após a escrita de um número válido e clicado no botão para uso do número, o mesmo
será armazenado na variável global “Telefone”. Além disso, foram utilizadas dos componentes
relativos a troca de mensagens: Texting1 e Texting2. O primeiro será utilizado para o envio de
mensagens enquanto o segundo para recebimento afim de deixar bem claro a divisão de envio
e recebimento onde o aplicativo enviará para o número de telefone armazenado as solicitações
e verificará as mensagens de resposta recebidas desse número.
Além disso, para que evitemos uma troca do número utilizado durante a sessão do
aplicativo podemos tornar invisível a caixa de texto e o botão para salvar o número de telefone
(esse item fica a critério do desenvolvedor). Podemos também criar um botão que torne os
elementos visíveis novamente para uma alteração do valor ou, como dito anteriormente, criar um
banco de dados que salve o número pertinente para as próximas inicializações do aplicativo
(temos noção suficiente da plataforma para explora-la a fundo e desenvolver mais!).
Feito esses procedimentos, também será exibido um alerta na tela informando que o
número foi salvo.
183
Com relação aos botões de escolha da caixa de diálogo quando o número está incorreto:
clicar em “Cancelar” apenas fechará a notificação (cancelable true) e clicar em “OK”, fará com
que o alerta “Tente novamente!” apareça.
Figura 5.50. Bloco para ação após a seleção do botão da caixa de notificação.
Os botões “LIGAR” e “DESLIGAR”, quando clicados, culminam em um erro que fecha a

aplicação naturalmente quando nenhum número para envio de mensagem é salvo. Quando o
número envio existe, o argumento de texto “ON”, quando clicamos em “LIGAR” ou ”OFF”, em
“DESLIGAR ”é acrescentado à função texting1 e uma chamada para o envio da mensagem é
feita através de “call Texting1.SendMessage”.
Figura 5.51. Botões utilizados para o envio de mensagem de acionamento ou desligamento da

lâmpada.
Feita a verificação da mensagem enviada pelo Arduino e o processo referente à

realimentação efetiva uma mensagem será retornada ao dispositivo Android e tratada pelo
mesmo para sua apresentação em tela através da estrutura mostrada na figura seguinte. Nela,
texting2 é utilizada, sendo nela armazenada a resposta recebida pelo número para que uma
verificação seja feita e interpretada dentro de um dos 4 quadrantes.
184
Figura 5.52. Bloco responsável pelo recebimento de mensagens e tratamento das mesmas para que
uma resposta seja apresentada na tela do aplicativo.
Finalizamos, então, o aplicativo. Temos agora todo o necessário para o funcionamento

desse sistema e, além disso, completamos as três formas de comunicação propostas à serem
apresentadas!
5.6. Mecanismos de realimentação
Embora tenhamos falado e utilizado em todos os sistemas montados o componente LDR

funcionando como sensor para a realimentação efetiva do sistema, existem diversos outros
dispositivos e sensores que podemos utilizar para detectar se o mesmo está funcionando
devidamente e encaminhar essa informação ao usuário.
Sensores como o LDR, embora sejam de baixo custo e cumpram com o propósito didático
do material não são os mais confiáveis para serem utilizados num sistema real por estarem
expostos a interferências do meio. Dessa maneira, o recomendado para um projeto real e de
confiabilidade seriam sensores de corrente.
185
Sensores de corrente podem ser conectados diretamente ao circuito da lâmpada sem que
interfiram de maneira significante no mesmo. Dessa maneira, o circuito fechado da lâmpada tem
a passagem de corrente capitado pelo sensor gerando um sinal que pode ser utilizado para
informar ao Arduino e, consequentemente, ao usuário do sistema sobre o real estado do mesmo.
Como exemplo podemos citar o reed-switch e o sensor de efeito hall.
REED-SWITCH
Esse dispositivo é um interruptor de lâminas formado por duas lâminas flexíveis
ferromagnéticas num encapsulado de vidro preenchido por gás inerte. O mesmo pode ser
acionado na presença de um campo magnético produzido por um imã ou por uma bobina. O
mesmo pode funcionar tanto em corrente continua quanto em corrente alternada e, dessa
maneira, podemos, ao associa-lo com uma bonina, liga-lo ao circuito da lâmpada para realizar a
realimentação efetiva.
Figura 5.53. Exemplo de um reed-switch. Fonte: < http://uk.rs-online.com/web/p/reed-

switches/2293658/>. Acessado em novembro, 2017
Figura 5.54. Esquema de um reed switch. Fonte: adaptação da imagem disponível em

<http://iamtechnical.com/reed-switch>. Acessado em: junho, 2016.
186
SENSOR DE CORRENTE POR EFEITO HALL
Um sensor de efeito Hall é aquele que, sob a aplicação de um dado campo magnético,
produz uma variação de tensão elétrica numa saída. Dessa maneira, utilizando um módulo de
sensor de corrente que utiliza do efeito Hall estamos detectando um campo magnético gerado
pela passagem de corrente, continua ou alternada, e gerando uma tensão proporcional na saída
desse módulo.
Figura 5.55. Visões de um módulo sensor de corrente que utiliza o efeito Hall.
187
6. Utilizando microcontroladores ARM STM32F1XX
A arquitetura ARM (Advanced RISC13 Machine) é uma arquitetura de processadores de

32 bits muito conhecida pela sua aplicação em sistemas embarcados como, por exemplo, os
dispositivos com sistema operacional Android, amplamente utilizados ao redor do mundo.
A ideia desses processadores é voltada para um baixo custo e consumo de energia
oferecendo um alto desempenho. E como estamos tratando nesse material de sistemas
envolvendo microcontroladores, é interessante apresentar outros dispositivos, tal como o ARM,
que também é capaz de controlar elementos ao seu redor, da mesma maneira como o Arduino
(ou melhor).
Será apresentado aqui um microcontrolador STM32 da série F1 (séries são baseadas em
torno do núcleo do processador utilizado), mais precisamente: o STM32F103C8T6.
MICROCONTROLADOR STM32F103C8T6
Uma placa de desenvolvimento que utiliza um processador ARM Cortex-M3, projetado
para fornecer uma plataforma de baixo custo para atender aos desenvolvedores mais exigentes.
Possui um regulador de tensão para 3.3V que suporta até 300mA14, um botão de reset e dois
jumpers, utilizados para ativar ou desativar seu modo de programação bootloader.
Também possui um extenso conjunto de pinos que envolvem entradas e saídas digitais
e analógicas, PWM’s, pinos para comunicação serial dentre outros diversos.
Comparado seu processador com o processador utilizado no Arduino Uno apresentado
nesse material (vide Fig. 3.3) temos uma arquitetura de 32-bits contra um de 8-bits do Arduino.
Lembrando também que, no microcontrolador utilizado para os projetos realizados aqui até o
momento, o pino analógico possui uma resolução de 10 bits, ou seja, é capaz de interpretar 1024
(ou 210) valores no intervalo de 0 à 1023 para conversão analógica-digital (pino ADC) do seu
nível de operação de 5V. Por sua vez, o ARM se mostra, novamente, uma ferramenta mais
poderosa e que agrega mais precisão tendo uma resolução de 12 bits (0 - 4095) com operação
em 3.3V.
13 RISC (acrônimo de Reduced Instruction Set Computer; em português, "Computador com um conjunto reduzido de instruções") é
uma linha de arquitetura de processadores que favorece um conjunto simples e pequeno de instruções que levam aproximadamente
a mesma quantidade de tempo para serem executadas.
14 É recomendável que não seja drenado da placa mais do que 100 mA.O regulador não possui proteção térmica e, dessa forma,
expô-lo a altas temperaturas (o que pode ser ocasionado por uma corrente elevada para o circuito do mesmo) pode facilmente
danificá-lo.
188
Além disso, o STM32F10C8T6 possui uma memória flash e SRAM maiores e uma maior
velocidade de seu processador e um preço em torno de R$15,00 sendo uma escolha mais
potente e mais barata que o Arduino.
Ao comparar os dois microcontroladores, conforme apresentada na tabela abaixo,
podemos observar os diversos aspectos onde o STM32F103 é potencialmente superior ao
modelo UNO. Além disso, o seu tamanho reduzido impressiona: um pouco maior que um Arduino
Nano!
Tabela 6.1. Breve especificação técnica do microcontrolador com informações básicas.

Especificações Técnicas STM32F103C8T6 Arduino UNO
Arquitetura 32 Bit 8 Bit
Velocidade processador 72 MHz 16 MHz
Memória Flash 64 kB 32 Kb
RAM 20 kB 2 Kb
Alimentação 2.5 – 5.5 V 7 – 12 V
Cristal RTC 32 kHz Não possui
SPI, I2C, UART,
Tipos de barramento SPI, I2C, UART
CAN
Pinos ADC 10 (12-bit) 6 (10-bit)
GPIO's 37 14
Figura 6.1. Dimensões do STM32F103C8T6 (acima) e do Arduino Nano (abaixo).
189
Figura 6.2. Pinagem de microcontrolador da série STM32F103. Fonte:
http://wiki.stm32duino.com/images/a/ae/Bluepillpinout.gif. Acesso em novembro, 2017.
O STM32F103C8T6 também é conhecido como Blue Pill. Além do já citado, é importante

informar, para uso do hardware, que os pinos devem ser alimentados com um máximo de 20mA,
sendo recomendado o uso de 8mA, tendo a placa um suporte máximo de 150mA (fornecimento
ou dreno).
Outra característica relevante é a ausência de uma proteção entre o sistema de entrada
de 5V e a entrada USB. Desse modo, não devemos energizar a placa simultaneamente pela
entrada USB e uma fonte de 5V, podendo essa ação causar dano irreversível.
BOOT MODES
Ao iniciar a placa, utilizamos os pinos de boot para selecionar uma de suas três opções
possíveis, conforme tabela abaixo.
Tabela 6.2. Modos de boot e como utiliza-los.

Modo de Boot do Jumper
BOOT 1 (PB2) BOOT 0 modo de boot
X 0 Memória flash (RUN)
0 1 Memória do sistema (PROGRAM)
1 1 SRAM da placa
190
Figura 6.3. Jumpers do microcontrolador em destaque. Os mesmos conectam os pinos 2 à 2. Fonte:
< https://www.davidpilling.com/wiki/files/STM/STM_board_DP0.jpg >. Acesso em novembro, 2017.
Do lado direito temos o esquema de sua pinagem retirados da Fig. 6.2.
ST-LINK
Para a programação e depuração utilizando a série STM32 é necessário o uso de
ferramentas auxiliares. Aqui, essa ferramenta será o ST-LINK15 um circuito capaz de realizar
essas funções. Ao desenvolver um código utilizaremos o hardware e software ST-LINK para
transmitir o programa corretamente ao microcontrolador, comunicação essa realizada com o
STM32 através da interface USB da ferramenta.
Figura 6.4. Versão do ST-LINK V2 que será referenciada nesse material. Fonte:
http://artofcircuits.com/product/st-link-v2-mini-stm8-stm32-programmer-debugger-with-metallic-
case. Acessado em novembro, 2017.
15 Podemos também utilizar um conversor USB para TTL.
191
Na Fig. 6.4 temos o ST-LINK V2, ferramenta que utilizaremos e que possui 10 pinos de
conexão, demarcados em sua cobertura, cuja ordem é como dada na figura a seguir.
Figura 6.5. Pinagem do ST-LINK V2.
Temos na ferramenta pinos de alimentação (3.3V e 5.0V) e terra (GND), pino de reset
(RST) e os pinos interface (SWIM – Single Wire Interface Module) e de depuração (SWDIO –
Single Wire Debugging in/out; e SWCLK, para sinal de clock ).
6.1. Por que utilizar o STM32F103C8T6
Como já apresentado, além de fazer uso de uma arquitetura de processador amplamente

difundida, existem uma série de vantagens quando comparado ao Arduino Uno.
Seja em número de pinos, velocidade ou tamanho o STM32F103C8T6 é uma opção mais
potente e que serve melhor ao usuário para seus desenvolvimentos em automação, adaptando-
se ao IDE do Arduino de modo a já tornar mais amigável o desenvolvimento de programas pela
familiaridade com a linguagem.
Sendo também de interesse um conhecimento mais profundo da plataforma, portas são
abertas para desenvolvimento em outras que se utilizem do ARM, trazendo oportunidades aos
entusiastas em prototipagem e desenvolvimento.
6.2. Utilizando o microcontrolador STM32F1 com o ST-LINK
Para o uso do microcontrolador, no que diz respeito à programação, iremos operar um

programa já de nosso conhecimento: o Arduino IDE. Isso é possível a partir da instalação de
algumas ferramentas, como será mostrado adiante.
Além disso, precisaremos instalar o driver do ST-LINK/V2 para que o programa desenvolvido
possa ser compilado para a placa.
192
PREPARANDO O ARDUINO IDE
Iremos abrir o IDE e acessar o Gerenciador de Placas, por onde localizaremos e faremos
a instalação do “Arduino SAM Boards” que seja compatível com o núcleo de processamento do
microcontrolador que estamos utilizando que, no caso, é o ARM STM32 Cortex-M3.
O Gerenciador de Placas é localizado no menu “Ferramentas”, onde devemos clicar na
opção “Placa: ‘Arduino//Genuino Uno‘” (nome da placa é referente à ultima utilizada) e, por fim,
em “Gerenciador de Placas...”. Uma janela semelhante ao do Gerenciador de Biblioteca.
Figura 6.6. Caminho para o Gerenciador de Placas.
Figura 6.7. Gerenciador de Placas com software localizado para sua instalação.
193
A instalação do software a aquisição para o Arduino IDE de um compilador otimizado
(GCC) para um microcontrolador ARM, tal como temos os vários para as diversas versões do
Arduino (Uno, Mega, Nano, Mini etc).
Finalizado esse passo, finalizaremos os arquivos necessários ao Arduino IDE por meio
do download e instalação do software Arduino STM32 baixando-o através da plataforma Github
pelo link <https://github.com/rogerclarkmelbourne/Arduino_STM32>.
O download será feito semelhante ao da biblioteca GSM clicando em “Clone or download”.
Figura 6.8. Recorte da página de download do software para uso do STM32 no Arduino IDE.
Destacado em vermelho temos o local para download.
Os arquivos para suporte das placas STM32 é compatível com versões 1.8.x do IDE,
mas, conforme o próprio repositor do próprio software informa, o programa ainda é experimental
e no caso de termos ideias de seu uso para sistemas críticos, estaremos assumindo os riscos de
uso desses arquivos.
Localizado o arquivo baixado, devemos descompacta-lo e copia-lo para a pasta
“hardware” do Arduino (normalmente localizada em C:\Arquivos de Programas (x86)\Arduino).
Ao tentar copiar os arquivos para a pasta, é possível que o acesso à mesma seja negado
e uma permissão de administrado seja dada, por se tratar da transferência de arquivos para uma
pasta do disco C. Forneça a permissão clicando em “Continuar”.
194
Figura 6.9. Solicitação de acesso ao transferir pasta descompactada para uma pasta do sistema.
Ao clicar em "Continuar" a transferencia é permitida.
Figura 6.10. Pasta "hardware" com arquivos STM32 instalados após permissão consedida.
Finalizado esse procedimento teremos novas opções de placas para serem utilizadas
com o Arduino IDE. Dentre essas opções, teremos “Generic STM32F103C series” a qual
utilizaremos para nosso microcontrolador.
195
Figura 6.11. Recorte da lista de placas do menu ferramentas com algumas das novas opções.
DRIVER PARA ST-LINK/V2

Precisamos agora configurar o ST-LINK através da instalação de seu driver. Para isso
será necessário o download do software ST-LINK/V2 driver que pode ser encontrado ao acessar
a seguinte página:
http://www.st.com/content/st_com/en/products/development-tools/software-development-
tools/stm32-software-development-tools/stm32-utilities/stsw-link009.html.
Ao final da página, em “GET SOFTWARE”, clicaremos no botão azul “Get Software”.
Figura 6.12. Recorte do final da página para download do driver para o ST-LINK/V2. O botão em
destaque desse ser clicado.
Em seguida, uma tela de acordo de licença (Licence Agreement) será apresentada e,

nela, devemos clicar em “ACCEPT” no início ou final da tela.
196
Figura 6.13. Final da tela com opção de aceite (“ACCEPT”).
É possível também, sendo de interesse, salvar como arquivo PDF o acordo de licença ao
clicar em “Save as PDF” antes de aceita-lo. Após o aceite, caso não tenha efetuado login ou não
possua um login para o site da ST, uma nova tela será apresentada.
Nela, temos a opção de nos registrar ou acessar a conta, clicando em “Login/Register”, e
a opção de apenas fornecer o nome (primeiro e último) e um endereço de e-mail (sendo de
interesse podemos marcar a caixa abaixo do e-mail para receber novidades no endereço
informado). Finalizado essa etapa devemos ainda realizar uma validação do e-mail informado.
Figura 6.14. Tela de registro/login para que o download possa ser iniciado. Podemos também
apenas repassar informações de nome e e-mail para inicia-lo.
197
Figura 6.15. Tela informando o registro e solicitando validação do e-mail após terem sido
informados nome e e-mail para liberação do download.
Em seu e-mail informado, clicar no link enviado por onlinesupport@notification.st.com

iniciará o download, finalmente.
Após o download, devemos localizar e descompactar o arquivo. Devemos então dar um
duplo click no arquivo executável “dpinst_x86.exe” ou “dpinst_amd64.exe”, dependendo se o seu
sistema operacional é de 32 ou 64bits, respectivamente.
Arquivos de
instalação
Arquivo a ser
descompactado
Figura 6.16. Arquivos após descompactação.
Em alguns casos podemos não ter certeza de qual sistema operacional possuímos em
nosso computador. Nesse caso, podemos utilizar o comando “Windows+X” e escolher a opção
“Sistema” e, na janela que será aberta, poderemos verificar tal informação.
198
Figura 6.17. Recorte da janela de informações do sistema com destaque na informação sobre o
sistema operacional.
Ao iniciar a execução do programa para instalação podemos ser informados que o arquivo
é de uma fonte desconhecida, sendo solicitada autorização. Permita o prosseguimento.
O assistente de instalação tem duas janelas: na primeira clicaremos em “Avançar>” e, na
segunda, iremos clicar em “Concluir” para finalizar o procedimento. É possível, também, que uma
janela com solicitação intermediária apareça pedindo permissão para a instalação do software
de dispositivo. Nesse caso, marcaremos a caixa “Sempre confiar em software...”, para que um
novo questionamento para programas envolvendo STM não seja feito, e em “Instalar”.
Figura 6.18. Janelas do assistente de instalação. À esquerda selecionaremos "Avançar >" e à

direita, em "Concluir".
199
Figura 6.19. Possível janela intermediária, solicitando permissão para instalaçao do software.
Finalizada a instalação, estamos agora aptos para programar e carregar o código no

STM32F103C8T6.
PROGRAMANDO O MICROCONTROLADOR COM O ST-LINK

Para exemplificar sua funcionalidade, faremos um projeto simples, tal como os iniciais
com o Arduino. O STM32FXXX possui um pino com LED integrado, denominado PC13, e
faremos com que ele pisque cada vez mais rápido até sua parada.
Para o funcionamento do programa devemos:
 conectar os pinos GND, 3.3V, CLK e DIO do microcontrolador ao pinos GND, 3.3V,
SWCLK e SWDIO do ST-LINK, respectivamente;
 conectar o ST-LINK/V2 a uma porta USB do computador;
 escolher o boot mode para PROGRAM (BOOT1 em 0 e BOOT0 em 1);
 configurar e carregar o código elaborado no Arduino IDE;
 escolher o boot mode para RUN (BOOT1 em 0 (X) e BOOT0 em 0);
 resetar a placa para que o código seja executado.
Figura 6.20. Configuração na placa dos jumpers para o boot mode "PROGRAM".
200
void setup(){
pinMode (PC13 , OUTPUT) ;
}
void loop(){
for(int i = 1000; i >= 0 ; i = i-100){
digitalWrite(PC13, HIGH);
delay(i);
digitalWrite(PC13, LOW);
delay(i);
}
}
Outros códigos de teste podem ser utilizados, caso seja de interesse. O uso do pino PC13
foi escolhido devido a comodidade de não ser necessário montar um circuito para o teste de
funcionamento do microcontrolar.
Escrito o programa, vamos agora configurar o IDE para a compilação do mesmo
determinando o modelo da placa, sua variante específica, velocidade de operação, meio de
upload e a otimização, conforme imagem à seguir, no menu “Ferramentas”. A cada seleção da
configuração, na sequência, as demais opções vão sendo apresentadas no menu.
Figura 6.21. Configuração da IDE para o carregamento do código no microcontrolador

STM32F103C8T6.
201
Podemos agora carregar o código e caso tudo ocorra bem verificaremos no campo de
notificações um texto final semelhante ao seguinte:
Programming Complete.
MCU Reset.
Application started.
Caso o campo de notificações informe o erro “Unable to connect to ST-LINK!” devemos

verificar a conexão entre o ST-LINK/V2 e a placa microcontroladora (verifique a conexão dos
jumpers e, de preferência, reconecte-os).
Agora iremos trocar novamente o boot mode, dessa vez para RUN, e apertaremos o botão
de reset da placa. Feito isso, o código será executado!
Figura 6.22. Configuração na placa dos jumpers para o boot mode "RUN".
6.3. Utilizando o microcontrolador STM32F1 sem o ST-LINK
É possível, por meio de programação, fazer com que não haja necessidade da conexão
com o ST-LINK para o funcionamento do microcontrolador de modo que possamos conecta-lo
diretamente ao computador. Assim, a placa pode funcionar por si só sem a necessidade de um
intermediador o que pode reduzir erros advindos da conexão entre os dois elementos e também
simplifica a montagem de circuitos de um sistema que o utilize.
Para isso, colocaremos um bootloader na placa o qual será responsável por “ensinar” ao
microcontrolador como receber outros programas e realizar as funções que normalmente seriam
feitas pelo ST-LINK diretamente pela porta USB.
Sendo assim, o bootloader nada mais é do que um programa cuja a principal função é
carregar códigos (programas do computador) para a memória do microcontrolador.
202
Para melhor entendimento do que faremos devemos esclarecer e recapitular alguns
pontos:
 Por padrão o microcontrolador já possui um bootloader, o qual é ativado pelo boot
mode que apelidamos de “PROGRAM”, mas o mesmo não é configurado para
receber programas diretamente pela porta USB;
 Quando ativamos o boot mode apelidado de “RUN”, o microcontrolador roda o que
é encontrado em sua memória, começando por um endereço inicial da memória
que, no caso, é o 0x08000000.
 Um programa ocupa pode ocupar parte ou toda a memória do microcontrolador
iniciando esse programa sempre em um endereço e terminando noutro
determinado (dependendo do espaço ocupado).
O que faremos, então, será colocar um programa (o bootloader) no início da memória do

STM32F1 – o que ocupará apenas uma porção da memória – que será responsável por receber
outros programas pela porta USB, grava-los no espaço restante e fazer o gerenciamento da
execução dos mesmos.
De maneira simplista teremos o bootloader padrão da placa utilizando um outro
bootloader na memória para gravar e utilizar outros códigos repassados por um projetista.
Precisaremos de dois novos programas para começar a utilizar esse novo bootloader:
 ST-LINK Utility;
 STM32duino-bootloader.
O primeiro é encontrado em:
https://www.st.com/content/st_com/en/products/development-tools/software-development-
tools/stm32-software-development-tools/stm32-programmers/stsw-link004.html.
O segundo em:
https://github.com/rogerclarkmelbourne/STM32duino-bootloader.
Como o primeiro programa é referente ao site ST, o procedimento inicial para o download
já foi discutido. Terminado de baixar, devemos descompactar o arquivo e dar um duplo clique no
novo arquivo que foi gerado.
O assistente de instalação será aberto para prosseguir com a mesma. No início
clicaremos em “Next >” (“Avançar >”) e, em seguida, no acordo de licença (License Agreement),
em “Yes” (“Aceitar”). Na sequência, teremos uma janela relativa ao local de instalação do
programa onde podemos deixar o padrão – ou escolher um outro clicando em “Browse...” – clicar
em “Next >” para continuar. A instalação seguirá seu curso.
203
Figura 6.23. Janelas iniciais do Assistente de Instalação. License Agreement à direita.
Figura 6.24. Janela para seleção da pasta de destino dos arquivos e prosseguimento da instalação.
A finalização dessa instalação pode ou não levar à abertura de um novo Assistente de

Instalação para um driver adicional necessário referente a portas de comunicação (COM e LPT).
Caso a janela apareça, clicaremos em “Avançar >”, em “Instalar”, na janela seguinte (caso seja
solicitada autorização), e “Concluir” na próxima e última. Após isso, devemos clicar em “Finish”
referente a janela do primeiro Assistente, caso ainda esteja aberta.
204
Figura 6.25. Nova janela de Assistente de Instalação. Nela, clicamos em "Avançar >".
Figura 6.26. Janela em sequencia solicitando autorização para instalação de driver Portas (COM e
LPT).
205
Figura 6.27. Conclusão da instalação do driver de portas.
Figura 6.28. Conclusão da instalação do ST-LINK Utility.
A instalação do ST-LINK Utility foi finalizada e iremos descompactar o arquivo baixado

na plataforma Github, o STM32duino-bootloader, que segue o mesmo processo já apresentado
das últimas vezes a respeito.
Iremos agora abrir o programa instalado ST-LINK Utility e, nele, iremos abrir um arquivo
(File > Open file...) da pasta gerada após descompactar o STM32duino-bootloader:
“generic_boot20_pc13.bin”. O arquivo .bin está localizado em “..\STM32duino-bootloader-
master\binaries” sendo “STM32duino-bootloader-master” a pasta gerada após descompactar o
bootloader da Github.
206
Figura 6.29. Imagem com sequência para abrir o arquivo .bin indicado.
Agora, com o arquivo aberto no programa, iremos conectar o ST-LINK/V2 ao computador

e à placa microcontroladora seguindo o mesmo esquema de conexões anteriores – pinos GND,
3.3V, CLK e DIO do microcontrolador ao pinos GND, 3.3V, SWCLK e SWDIO do ST-LINK,
respectivamente – e ordenar os jumpers para o boot mode PROGRAM.
207
Figura 6.30. Conexão e BOOT MODE ajustado para PROGRAM.
Feito isso, iremos conectar o programa à placa ao clicar em “Target” na barra de menus
e, em seguida, “Connect” ou no botão em formato de tomada com os pinos voltados para cima.
Figura 6.31. Janela do programa após abertura do arquivo " generic_boot20_pc13.bin ". Em
destaque temos o botão que conecta o software ao VT-LINK/V2.
208
Em caso de algum erro ser apresentado na área inferior branca da janela do software
devemos verificar se a conexão com o microcontrolador foi efetuada corretamente e/ou se a porta
USB do computador está funcionando corretamente (tente conectar outro periférico nela). Caso
tudo funcione corretamente, teremos algo parecido com a janela da figura à seguir.
Figura 6.32. Janela do software após conexão com ST-LINK/V2 efetuada com sucesso.
Os quadros em destaque tem as seguintes informações:
 Azul – informações da placa.
 Amarelo – dispositivo conectado.
 Verde – arquivo carregado.
 Laranja – informação da memória.
 Roxo – buffer.
Antes de colocar o bootloader devemos apagar todo e qualquer arquivo (como o

programa que rodamos anteriormente) da memória do microcontrolador. Para tanto, devemos
selecionar a aba “Device Memory...” e clicar no ícone semelhante à uma borracha (ou selecionar
“Erase Chip” no menu “Target”). Um alerta informando que o procedimento de apagar a memória
será permanente aparecerá nos questionando se desejamos continuar o procedimento e, na
janela desse alerta, clicaremos em “OK”.
209
Figura 6.33. Limpando a memória do dispositivo. Para isso selecionamos a aba "Device Memory"
e podemos clicar no ícone da borracha.
Figura 6.34. Alerta apresentado em tela ao tentarmos apagar a memória. Devemos clicar em "OK".
Ao final desse procedimento, teremos a memória vazia e o passo seguinte consiste em

transferir o bootloader para a memória. Para isso, passaremos para aba “File” (referente ao
programa que carregamos com destaque em verde na Fig. 6.32) e, também no menu “Target”,
clicaremos em “Program & Verify...” (ou no ícone de uma folha com lápis).
Figura 6.35. Conteúdo apresentado na aba Device Memory quando a memória está limpa.
210
Figura 6.36. Em destaque temos os passos para repassar o bootloader desejado à placa.
Uma nova janela será aberta para que possamos configurar algumas questões sobre a
gravação que iremos fazer:
 Start adress – endereço inicial de memória onde colocaremos o programa do
bootloader. Como dito anteriormente, o primeiro endereço da memória é
0x8000000 e é neles onde iniciaremos a gravação.
 File path – local do arquivo que vamos carregar. No caso, esse caminho é onde
“generic_boot20_pc13.bin” está localizado e se o caminho não for dado, podemos
localizar o mesmo clicando em “Browse” para que ele seja automaticamente salvo
no campo quando localizado.
 Extra options – aqui temos dois campos que, para o nosso caso, não marcaremos.
Quando marcados, o primeiro pula a limpeza da memória flash e o segundo pula
uma verificação de proteção que é feita também em flash.
 Verification – traz duas opções de verificação do código que será carregado: a
primeira, e selecionada, enquanto o microcontrolador está sendo programado pelo
software e a segunda, após.
 After programming – temos ações possíveis após a programação do
microcontrolador realizada pelo software. A primeira, e única selecionada,
realizará um reset após a ação e a segunda realiza um checksum completa da
memória flash (verifica a integridade dos dados transmitidos).
211
As opções selecionadas podem ser visualizadas na figura abaixo. Ao clicarmos em “Start”
para iniciar o a programação no microcontrolador o progresso pode ser observado na barra
abaixo do texto “Click ‘Start’ to program target.”.
Figura 6.37. Janela do software para configuração da programação do microcontrolador. No caso,

ele será programado com o bootloader do nosso interesse.
Em seguida poderemos notar que as abas “Device Memory” e “File” estão iguais, com as
informações semelhantes em cada endereço da memória. O que significa que o código agora
presente na memória do microcontrolador é exatamente igual ao do arquivo
“generic_boot20_pc13.bin”.
Figura 6.38. À esquerda temos a aba "Device Memory" e, à direita, "File". Podemos notas que as
posições de memória guardam as mesmas informações.
Estamos chegando próximos ao fim. Iremos desconectar a placa do software clicando,

primeiramente, na aba “Device Memory” e, em seguida, em “Disconnect” na aba “Target” ou,
212
como já temos feito, à partir dos ícones do software clicando na tomada com um “X” desenhado
em vermelho.
Figura 6.39. Desconexão entre software e o ST-LINK/V2.
Seguidos esses passos até o momento, procederemos com a instalação de um último

driver: o Maple DFU. Para que isso seja possível navegaremos até a pasta onde o Arduino foi
instalado e um pouco além, seguindo o caminho que, por padrão das instalações feitas, seria:
“C:\ Program Files (x86)\Arduino\hardware\Arduino_STM32-master\drivers\win” (sem aspas)
num sistema Windows..
Na pasta de arquivos em aberto, devemos selecionar “install_drivers.bat” com o botão
direito e solicitar que o mesmo possa “Executar como administrador”, garantindo-lhe as
permissões necessárias. Ao ser finalizada a execução do arquivo, cujo progresso será mostrado
numa janela de cmd no Windows, clicamos em qualquer tecla para que a janela de progresso
seja fechada e terminada a instalação do Maple DFU.
Figura 6.40. A seleção de "Executar como adminstrador" deve ser feita para que a execução de
"install_drivers.bat" seja permitida.
213
Figura 6.41. Tela de execuação do arquivo "install_drivers.bat". Ao finalizar as instalações
necessárias, devemos clicar em alguma tecla.
POSSÍVEIS ERROS AO FINALIZAR OS PROCEDIMENTOS

No percurso de todas essas configurações necessárias para o funcionamento do
STM32F1 sem a sua associação com o ST-LINK/V2 foram constatados alguns erros que, embora
tenham certa simplicidade em sua resolução, são essenciais para o funcionamento do
microcontrolador e, portanto, imprescindíveis de serem abordados para que a experiência desse
modo de funcionamento não seja, de certa forma, mais complexa do que a abordagem inicial
apresentada.
O que foi observado e como corrigir caso ocorra:
 Pode ocorrer de o computador não reconhecer por completo o bootloader
aplicado. Para esse caso, devemos desconectar o cabo que liga a placa ao PC,
reinicia-lo e tentar novamente.
 Pode ocorrer de, numa primeira vez após as configurações serem feitas, o
computador não reconhecer o Maple DFU como sendo uma COM, mas como
sendo um outro componente de entrada USB. Nesse caso, iremos prosseguir com
o carregamento de um dado código na placa sem nos preocuparmos com a
seleção de “Porta” no menu “Ferramentas”.
214
Figura 6.42. Microcontrolador localizado como um componente de entrada USB.
 Ocasionalmente, é possível que o Arduino IDE não encontre o arm-gcc (o

entendimento entre a placa e o ambiente de desenvolvimento não será possível).
Uma solução rápida seria fechar e reabrir o IDE, mas caso seja de interesse
prevenir que isso ocorra novamente, devemos acessar https://launchpad.net/gcc-
arm-embedded/+download”, baixar e instalar o “GNU ARM Embedded Toolchain”
de acordo com o sistema operacional utilizado indicado em “ Description”.
Num sistema com Windows baixaríamos, por exemplo, o arquivo em destaque na
figura a seguir.
Figura 6.43. Página de download do arm-gcc. Em destaque, o arquivo executável instalador para
Windows.
215
PROGRAMANDO O MICROCONTROLADOR DIRETAMENTE NA PORTA USB
Terminados todos os procedimentos anteriores iremos, finalmente, desconectar o ST-
LINK/V2 do nosso STM32F1XX e colocaremos seus jumpers no boot mode RUN, no qual ele
ficará permanentemente agora tendo em vista que utilizávamos PROGRAM para rodar o
bootloader padrão da placa juntamente ao ST-LINK para que pudéssemos carregar os
programas na placa.
Ao ligar o microncontrolador a um cabo USB conectado ao computador, o LED do pino
PC13 irá piscar, o que indica que o indica que nosso bootloader instalado está em funcionamento
e poderemos carregar nossos programas na placa sem a necessidade do ST-LINK e de alteração
do boot mode para PROGRAM.
Utilizando o mesmo programa que fizemos anteriormente para rodar na placa, ou um de
sua escolha, iremos configurar o Arduino IDE para funcionar com o microcontrolador conforme
já fizemos, porém, com algumas alterações. Veja a figura:
Figura 6.44. Configuração do IDE para funcionamento com bootloader do microcontrolador.
Além disso, em “Porta”, deveremos informar em qual porta o microcontrolador ARM está
conectado. Caso desconheça essa informação ou a mesma não esteja clara, podemos verificar
216
essa questão através do Gerenciador de Dispositivos, selecionando-o na lista de opções aberta
pelo comando “Windows+X” (em máquinas Windows).
No Gerenciador de Dispositivos, o identificador da porta onde o ARM está conectado tem
a denominação “Maple Serial”.
Sendo o mesmo reconhecido como uma COM e sendo a porta selecionada corretamente
no IDE do Arduino temos todas as configurações necessárias para realizar o carregamento do
código na placa.
Figura 6.45. Identificação da porta serial onde o microcontrolador está conectado. No caso da
figura: COM8.
Utilizando do mesmo exemplo da sessão anterior para uso do microcontrolador com o

ST-LINK, clicaremos no IDE para carregar o programa e, finalizado o carregamento, poderemos
ver o LED piscar cada vez mais rápido.
6.4. Aplicação e particularidades
Todos os projetos realizados com o Arduino podem, também, serem realizados utilizando o
STM32F103C8T6. Porém, algumas diferenças básicas como a já citada nomenclatura dos pinos
devem ser levadas em conta caso queiramos portar um código de uma base para a outra, mesmo
que utilizando o mesmo IDE para escreve-los.
Além disso, devemos nos atentar em algumas conexões de hardware para uso dos módulos
e Shields. Algumas dessas diferenças de hardware também podem afetar a análise via software,
como exemplo já citado da resolução dos pinos ADC.
217
Para que possamos ter uma correlação mais precisa sobre as funções e suas diferenças com
relação as das placas Arduinos, além de questões de portabilidade os seguintes materiais de
apoio são recomendados:
 Fórum sobre o uso de placas STM32 pelo Arduino IDE:
https://www.stm32duino.com/;
 Documentação completa sobre códigos do STM32F1:
https://github.com/rogerclarkmelbourne/Arduino_STM32/tree/4021c32fdb809f16a
61c073d04e1d8c2c487a767/STM32F1;
 Documentação Maple, a começar pelo index da linguagem:
http://docs.leaflabs.com/static.leaflabs.com/pub/leaflabs/maple-
docs/0.0.12/language-index.html. Embora não seja atualizado a muitos anos,
informações básicas sobre a programação são uteis e podem ser buscadas no
site.
Para mostrar algumas das diferenças quando utilizamos esse microcontrolador, iremos
refazer o projeto de comunicação via bluetooth e ethernet, portáveis para a placa.
6.5. Comunicação via Bluetooth
O microcontrolador possui uma extensa quantidade de pinos com funções diversas.

Observando cuidadosamente a Fig. 6.2 é possível notar a existência de três conjuntos de pinos
de comunicação serial: RX1/TX1, RX2/TX2, RX3/TX3.
Além disso, o microcontrolador trabalha com tensão de 3.3V. Isso significa que em
projetos onde utilizamos módulos de comunicação e sensores cuja tensão padrão para
transferência de dados é de 3.3V e alimentação do sistema é de 5V, não haverá necessidade de
nenhuma montagem auxiliar para conversão de tensão, como era preciso no modelo Uno, com
portas RX/TX e demais de GPIO em 5V.
MONTAGEM DO SISTEMA
No projeto em questão isso significa que não precisaremos do divisor de tensão utilizado
para a conexão com o RX do módulo Bluetooth. Assim, a montagem ficaria como se segue na
Fig. 6.53 (mostrada algumas paginas adiante, após um breve embasamento para chegarmos at),
já seguindo nosso padrão da realimentação efetiva.
Porém, embora a montagem pareça simples, o módulo relé que viemos utilizando até o
momento nos projetos com Arduino Uno é inviável para uso junto ao Blue Pill e algumas questões
218
devem ser previamente apresentadas e compreendidas antes de fazermos a montagem
sugerida.
A incompatibilidade está relacionada às características de corrente de saída dos pinos de
I/O dos dois microcontroladores: a placa foi desenvolvida para o Arduino, cuja saída é de 40mA,
enquanto a saída do Blue Pill é de 20mA.
Essa diferença faz com que o chaveamento do relé no módulo não funcione propriamente
e, desse modo, o indicado é que montemos nosso próprio módulo. Precisaremos então aprender
a selecionar cada um de seus componentes.
Devemos começar pelo relé, nos baseando nas características de alimentação que serão
fornecidas e a carga que será controlada. Para isso, utilizaremos um relé de 5V que suporte a
carga da rede elétrica de 220V como, por exemplo, o modelo SRD-05VDC-SL-C.
Embora esse seja um relé para alimentação em 5V, sua escolha foi tida para que uma
montagem futura fosse compatível tanto para Arduino, quanto para os demais
microcontroladores16, dispensando o uso do módulo pré-projetado e economizando recursos
financeiros, alterando apenas componentes mais baratos para adaptação do uso. Além disso,
entendendo os princípios de escolha dos componentes e a ideia de montagem, seremos capazes
selecionar e montar diferentes módulos por conta própria.
Vcc/GND
NA
Comum
NO
GND/Vcc
Figura 6.46. Relé para 5V, em corrente continua, para uso em tensão de rede 127/220V (corrente
alternada). Modelo: SRD-05VDC-SL-C.
Em seguida, devemos examinar a corrente exigida pelo relé para o funcionamento de sua
bobina. Para isso, precisamos do datasheet (folha de dados) do componente, onde podemos
encontrar essa informação.
Para informações acerca dos datasheets a serem utilizados consulte o Anexo III
16Os microcontroladores apresentados nesse material possuem pelo menos um pino que pode prover 5V,
caso o circuito do microcontrolador seja alimentado com uma fonte que permita esse fornecimento.
219
Em primeiro lugar, devemos entender sobre a sigla do modelo, para saber se a bobina do
relé é do tipo high sensibility ou standard, informação relevante para verificação da corrente
correta.
Figura 6.47. Informação sobre o modelo do relé. Fonte: http://www.circuitbasics.com/wp-

content/uploads/2015/11/SRD-05VDC-SL-C-Datasheet.pdf. Acesso em out/2018.
Da Fig. 6.47, temos que o modelo do nosso relé tem a bobina (coil) do tipo “L:0.36W”.
Buscando essa informação na Fig. 6.48, temos que a bobina tem high sensibility e a corrente
necessária para o seu funcionamento é de 71.4mA.
Figura 6.48. Informação sobre a bobina do relé. Fonte: http://www.circuitbasics.com/wp-

content/uploads/2015/11/SRD-05VDC-SL-C-Datasheet.pdf. Acesso em out/2018.
O valor exigido de corrente é superior ao que o Blue Pill (e, também, o Arduino Uno) é
capaz de oferecer. Assim, como proteção para o sistema, utilizamos um transistor para
intermediar o chaveamento.
O transistor de escolha deve suportar o valor de aproximadamente 72mA exigido pela
bobina como, por exemplo, o BC237.
Figura 6.49. Transistor BC237 com indicação dos pinos coletor(C), base (B) e emissor (E).
220
No coletor do transistor será conectado o Vcc do microcontrolador, fornecendo 5V. No
emissor, ligaremos o GND e, na base, conectaremos um pino digital que será o responsável por
saturar o BC237 e ativar o relé quando solicitado.
O papel do resistor entre o pino digital e o transistor tem o papel de limitar a corrente que
chega até a base de forma a não causar danos ao componente e ao microcontrolador ao fechar
um circuito fluindo da base ao emissor (GND).
O cálculo do valor do resistor a ser utilizado faz referência a esse circuito, como
apresentado na Fig. 6.50.
Ib Rb
V = 5V
VQ1 = 0,7V
Figura 6.50. Circuito a ser considerado para o cálculo do resistor R1.
Da Primeira Lei de Ohm, temos que:
𝑈
𝑅=
𝐼
𝑉 − 𝑉𝑄1
𝑅𝑏 =
𝐼𝑏
Onde:
Rb é a resistência na base;
V é a tensão entregue pelo pino digital;
VQ1 é a queda de tensão que ocorre quando a corrente passa pelo resistor;
221
Ib é a corrente que passa pela base.
Nos transistors, há uma relação entre a corrente do coletor e a corrente da base chamada
ganho (β ou ℎ𝐹𝐸 ). O ganho ℎ𝐹𝐸 representa a quantidade de vezes em que uma corrente é
amplificada baseando-se na quantidade de corrente aplicada na base do transistor. Assim:
𝐼𝑐
𝐼𝑏 =
ℎ𝐹𝐸
A corrente no coletor é dada pela corrente necessária para ativar o relé e, nesse caso,
usaremos o valor aproximado de 72mA, para uma pequena margem de segurança.
Pelo datasheet do BC237, temos ℎ𝐹𝐸 = 120. Desse modo:
72
𝐼𝑏 = = 0,6 𝑚𝐴
120
Com isso, da relação da Primeira Lei de Ohm, podemos encontrar o valor do resistor que
precisamos. Teremos, então, que:
5 − 0,7 4,3
𝑅𝑏 = −3
=
0,6 ∗ 10 0,6 ∗ 10−3
𝑅𝑏 = 7,17 ∗ 103 Ω
Como se tem que garantir pelo menos esta corrente 𝐼𝑏 para que a corrente no relé não
seja menor que a especificada. O valor calculado para 𝑅𝑏 é o valor máximo.
Assim, comercialmente, o valor mais próximo e inferior ao calculado é de 6800Ω (ou 6K8,
em terminologia mais comercial).
Figura 6.51. Resistor de 6k8 Ω. Fonte: https://produto.mercadolivre.com.br/MLB-773564138-

resistor-6k8-14w-5-pct-100-pcs-_JM. Acesso em out/2018.
222
Por fim, temos o diodo de freewheeling. O mesmo deve ser capaz de suportar a corrente
de 71,4mA e a tensão de 5V relativas ao circuito do relé.
Analisando essas características, o diodo 1N4001 é capaz, segundo seu datasheet, de
atender as necessidades do circuito e teremos, por fim, todos os componentes para a montagem
do nosso módulo conforme Fig. 6.52.
NO
NA
RLY1
Pino
de I/O
GND
Figura 6.52. Esquema de montagem do módulo relé. Vcc e GND devem ser conectados à uma
alimentação de 5V do microcontrolador e pino GND.
Os terminais a serem utilizados para a conexão da lâmpada dependem do seu interesse

e a programação também dependerá disso. Fique atento!
Se conectarmos a lâmpada ao contato normal aberto (NA) e tratando-se o transistor (Q1)
utilizado do tipo NPN, por exemplo, o sinal digital de alta (HIGH) faz com que a lâmpada acenda.
Nos projetos utilizando o módulo projetado para Arduino, vimos que a programação
aponta o sinal de baixa (LOW) como o responsável pelo acionamento da lâmpada. Isso se dá
pelo fato de o módulo utilizar-se de um transistor PNP que, grosseiramente, funciona
inversamente ao PNP no nosso caso de uso.
A seguir, a montagem citada ao início do tópico. Nela, foram omitidas as conexões com
relé e lâmpada, com exceção do pino digital ao qual foi conectado.
223
Módulo Relé
Alimentação
e lâmpada
via microUSB
Figura 6.53. Montagem do sistema de comunicação via Bluetooth utilizando o microcontrolador

ARM. O relê e a lâmpada foram omitidos para simplificação e foco na montagem do circuito
Bluetooth. O circuito com sensor foi apresentado para não deixar dúvidas que apenas o divisor de
tesão associado ao módulo Bluetooth não é mais necessário.
A conexão do microcontrolador com o módulo Bluetooth foi feita utilizando as portas

A2(TX2) e A3(RX2). Note que apenas o Bluetooth não utiliza mais o divisor de tensão, tendo em
vista que os pinos fornecem 3.3V. Mas para a medida de variação de tensão com a luminosidade,
o LDR ainda deve utilizar um circuito divisor.
O microcontrolador deverá ser alimentado via seu microUSB e, dessa maneira, o pino
5V17 pode ser utilizado para alimentar o módulo Bluetooth.
PROGRAMAÇÃO NO ARDUINO IDE

A montagem do aplicativo e sua programação continuam as mesmas e, por esse motivo,
não serão rediscutidas aqui.
17 O pino 5V pode ser utilizado tanto para o fornecimento de tensão à componentes conectados ao microcontrolador quanto para
alimentação da placa por uma fonte externa, desde que não seja usado, simultaneamente, a alimentação via microUSB (como já
comentado).
224
Por outro lado, a programação no IDE tem algumas adaptações, reflexos das
particularidades do STM32F103.
A declaração de pinos, por exemplo, não é feita com o número GPIO que representa, mas
segue o padrão “P” + “nome do pino”. Assim, o pino B1 e A4, que terão a função de enviar o sinal
de controle ao relé e a verificação dos valores do LDR no código a ser mostrado,
respectivamente, foram declarados como PB1 e PA4. A Fig. 6.2 indica os nomes dos pinos para
conferencia.
Cada pino pode executar diversas funções e, diferente do Arduino onde os pinos
analógicos tinham como função primária o input de informações, no ARM é necessário declarar
que um dado pino será usado como entrada analógica para que não ocorram erros ou algum
possível dado à placa.
A declaração é feita pela função pinMode(), como será mostrado no início do setup()
do código.
A parte mais diferente vem agora: a inicialização de duas comunicações seriais. Diferente
do visto até o momento, por existirem diversos pinos para comunicação serial, ao utilizarmos
uma das comunicações RX/TX devemos especifica-la para iniciar a comunicação por “serial1”,
”serial2” ou ”serial3”. E para fins de utilizar o Serial Monitor, utilizaremos apenas a palavra “serial”
para referência. Assim, ao utilizarmos os Serial Monitor e o Bluetooth, ou qualquer outro
componente que utilize uma porta de comunicação serial, os dois devem ser declarados.
Veremos a seguir o código, para verificação do que foi exposto no momento e, em
seguida, podemos testar seu funcionamento normalmente, como temos feito até agora.
225
const int rele = PB1; //pino de acionamento do rele
const int analogPin = PA4; //pino de leitura analogica do LDR
int ambiente = 0;
int LDR = 0;
char leituraBT;
int resposta;
void setup() {
pinMode(analogPin, INPUT_ANALOG);
Serial.begin(9600); //para uso do Serial Monitor
Serial2.begin(9600); //Para comunicacao bluetooth

}
Serial.print("Valor inicial de luminosidade do ambiente: ");
Serial.println(ambiente); //manda para o serial monitor o maior valor de
luminosidade obtido
}
void loop() {
DetectaLuzTempo();
if(Serial2.available()){
leituraBT = Serial2.read(); //leitura do recebido via bluetooth
Serial.println(leituraBT); //avalia para print no Serial Monitor
if(leituraBT == 'L'){
Serial.println("LIGOU");
}
if(leituraBT == 'D'){
Serial.println("DESLIGOU");
digitalWrite(rele, LOW);
}
}
226

Serial2.write('L'); Serial2.write('i'); Serial2.write('g');
Serial2.write('a'); Serial2.write('d'); Serial2.write('o');
Serial2.write(' '); Serial2.write(' '); Serial2.write(' ');
Serial2.write(' ');
}
else{ //envio de informacao pelo bluetooth

Serial2.write('D'); Serial2.write('e'); Serial2.write('s');
Serial2.write('l'); Serial2.write('i'); Serial2.write('g');
Serial2.write('a'); Serial2.write('d'); Serial2.write('o');
Serial2.write(' '); Serial2.write(' '); Serial2.write(' ');
Serial2.write(' ');
}
}


if(digitalRead(rele) == HIGH)
else{
ambiente=0;
}
}
}
}
227
6.6. Comunicação via Ethernet
Para esse projeto as mudanças em hardware são dadas pela diferente forma de conexão
entre o microcontrolador e o shield Ethernet.
Quando fizemos a conexão com o Arduino Uno tudo foi bem simples: bastava encaixar uma
em cima do outro. Mas quando se trata da conexão com o STM32F1, devemos nos atentar em
quais são os pinos corretos a serem ligados no shield ou módulo ethernet18 de interesse.
Sabendo a ordem e o nome dos pinos, a ligação entre os dois componentes é bastante
simples. Veja:
Tabela 3. Relação entre nomes dos pinos que devem ser conectados entre o microcontrolador e a
placa que irá possibilitar a comunicação Ethernet.
STM32F103C8T6 Shield/Módulo com W5x00
PA4 SS
PA5 SCK
PA6 MISO
PA7 MOSI
Nessa relação, PA4 à PA7 nada mais são do que os pinos que possuim em uma de suas
funções as mesmas expressas na segunda parte da tabela 10 e tensão de 3.3V.
Figura 6.54. Recorte do pinout do STM32F103C8T6 com identificação dos pinos do

microcontrolador a serem conectados com a placa de conexão Ethernet. Esses pinos têm a mesma
função dos pinos aos quais serão conectados. Os circulos vazio na marcação da esquerda inferem
que os pinos são de 3.3V.
18Como o importante para a comunicação é o componente de interface WIZnet W5x00 (W5100, W5200
ou W5500) a montagem do circuito pode ser realizada com um módulo que contenha o chip ou pelo shield,
como fizemos anteriormente ao utilizar o Arduino.
228
MONTAGEM DO SISTEMA
A única modificação que teremos será com relação a conexão do microcontrolador e do
módulo/shield a este. Além disso, embora tenha sido representado o módulo relé do Arduino na
Fig. 6.55, o módulo é meramente ilustrativo.
O fio amarelo conecta-se ao transistor (passando pelo resistor) e os fios vermelho e preto
fazem as conexões com Vcc e GND, respectivamente (rever Fig. 6.52).
Circuito
lâmpada
Módulo/
Shield
Ethernet
Alimentação
via microUSB
Figura 6.55. Esquema de montagem para uso do microcontrolador ARM com um módulo/shield
Ethernet para controle de lâmpada. O módulo relé mostrado na imagem deve ser propriamente
elaborado para uso com o microcontrolador em questão.
O Módulo deve ser alimentado em 5V, podendo essa tensão ser fornecida pelo próprio
microcontrolador pelo pino 5V (já conectado ao protoboard) quando a placa é alimentada pela
porta microUSB, como no caso da Figura 4.48. Como exemplo para conexão das duas placas,
considere a relação dos pinos apresentados na figura à seguir.
A conexão no shield também poderia ter sido feita nos pinos 10 (SS), 11(MOSI), 12(MISO)
e 13 (SCK). Os mesmos são espelhos do cabeçalho ICSP (In-Circuit Serial Programming), que
é o protocolo de comunicação que, simploriamente falando, é utilizado entre o microcontrolador
e a placa para utilizarmos as propriedades do Ethernet.
É importante também ressaltar que os pinos de GND devem estar numa mesma
referência. Embora não citado nas imagens de montagens anteriores, perceba que todos os
circuitos possuem um ponto de aterramento em comum interligando os pinos GND. É importante
229
sempre observarmos isso, pois sendo a tensão uma grandeza dependente de seu referencial,
referencias diferentes causariam um funcionamento inesperado do circuito e valores
inconsistentes de tensão, caso fosse possível medi-los.
PA4
PA6
5V
PA7
GND*
PA5
*no mesmo GND do microcontrolador para

manter a referência de tensão.
Figura 6.56. Indicações dos pinos da placa com Wiznet W5100 a serem usados e respectivos pinos
do microcontrolador onde devem ser ligados. A montagem é semelhante no Wiznet W5500.
Na Figura 4.49 é possível observar um resistor de 4.700Ω entre o pino de 3.3V e o

RESET. A montagem desse circuito é necessária para que, ao alimentarmos o shield para o
funcionamento do sistema completo, a placa seja adequadamente reiniciada para a operação do
software programado. A alimentação em 3.3V (ou 5V) manda um sinal ao RESET para efetuação
essa ação.
Quando utilizamos um módulo Ethernet, o mesmo deve ser feito: devemos identificar o
botão de reset e alimenta-lo.
230
Figura 6.57. Módulo Wiznet W5100 com indicações das conexões a serem feitas entre esse e o
microcontrolador. Fonte:
https://github.com/rogerclarkmelbourne/Arduino_STM32/tree/4021c32fdb809f16a61c073d04e1d8c
2c487a767/STM32F1/libraries/Ethernet_STM. Acesso em: outubro, 2018.
PROGRAMAÇÃO NO ARDUINO IDE

Antes de partimos para o código em si, devemos nos atentar em qual tipo de controlador
Ethernet estamos utilizando. A biblioteca tem suporte aos chips W5100, W5200 e W5500,
utilizando como padrão o W5500.
Dessa forma, para o uso de algum outro dentre os modelos citados, devemos acessar o
arquivo “w5100.h” e editá-lo . O arquivo está localizado na pasta do “Arduino_STM32-master”,
que adicionamos aos arquivos para uso do microcontrolador, em
“..\Arduino\hardware\Arduino_STM32-master\STM32F1\libraries\Ethernet_STM\src\utility”.
Figura 6.58. Imagem com possível caminho da raiz até a pasta que contem o arquivo "w5100.h" a
ser editado.
Ao abrir o arquivo, será possível localizar nas linhas inicias as definições do chip que será
utilizado:
//#define W5100_ETHERNET_SHIELD // Arduino Ethenret Shield and Compatibles ...
//#define W5200_ETHERNET_SHIELD // WIZ820io, W5200 Ethernet Shield
#define W5500_ETHERNET_SHIELD // WIZ550io, ioShield series of WIZnet
231
Temos por padrão, como já foi dito, o uso do W5500. Aqui, devemos deixar
descomentado apenas a linha que será utilizada e, sendo ela a referente ao chip W5100,
teremos:
#define W5100_ETHERNET_SHIELD // Arduino Ethenret Shield and Compatibles ...
//#define W5200_ETHERNET_SHIELD // WIZ820io, W5200 Ethernet Shield
//#define W5500_ETHERNET_SHIELD // WIZ550io, ioShield series of WIZnet
Feito a alteração, devemos salvá-lo e recompilar nosso sketch para que as mudanças
sejam efetuadas no nosso código.
Passando, então, para o código as alterações a serem feitas são apenas para a correta
declaração dos pinos e biblioteca referente ao protocolo Ethernet para o STM32F1. Veja:
#include <SPI.h>
#include <String.h>
#include <Ethernet_STM.h> //biblioteca Ethernet para o STM32F103C8T6
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x9B, 0x36 };

byte ip[] = { 192, 168, 0, 178 };
EthernetServer server(8090);
const int rele = PB10; // Pino onde o modulo de rele estah ligado
const int analogPin = PA1; //pino de leitura analogica do LDR
boolean status_lamp = false;
String readString = String(30);
int ambiente = 0;
int LDR = 0;
int resposta;
Nessa primeira parte, de declarações e cabeçalhos, temos todas as mudanças que são
necessárias para o funcionamento do código já elaborado para Arduino no capitulo anterior:
nome da biblioteca, pino do rele e pino de leitura analógica. Ademais, seguimos com as mesmas
linhas de código:
232
void setup() {
Ethernet.begin(mac, ip);
Serial.begin(9600);

}
}
void loop() {
DetectaLuzTempo();
EthernetClient client = server.available();
if (client){
while (client.connected()){
if (client.available()){
char c = client.read();
if (readString.length() < 30)

{
readString += (c);
}
if (c == '\n'){
if(readString.indexOf("LigarLampada")>=0)
{
status_lamp = true;
delay(500);
}
if(readString.indexOf("DesligarLampada")>=0)
{
delay(500);
}
233
client.println();
client.print("<font size='20'>");
resposta = analogRead(analogPin );
if (status_lamp){
client.println("ComandoLigar LuzLigada");
else
client.println("ComandoLigar LuzDesligada");
}
else if(status_lamp == false){

client.println("ComandoDesligar LuzDesligada");
else
client.println("ComandoDesligar LuzLigada");
}
readString="";
client.stop();
}
}
}
}
}
234
7. O microcontrolador NodeMCU ESP8266
O NodeMCU ESP8266, mais precisamente em sua terceira versão, é um microcontrolador

baseado no módulo ESP-12E WiFi, com processador RISC 32-bit.
É uma placa de prototipagem potente e traz a praticidade para uso de uma rede sem fio,
nativa à placa, agregando potencial para desenvolvimentos em IoT (Internet of Things ou Internet
das Coisas) e sendo igualmente capaz ao STM32F1 de utilizar o Arduino IDE para a
programação. Além disso, é programável em LUA, linguagem multiparadigma, desenvolvida na
PUC-Rio, leve e flexível.
O chip ESP8266 tem suporte pare rede IEEE 802.11 b/g/n (rede Wi-Fi difundida e utilizada
hoje em dia), trabalha em frequência de 2.4GHZ, suporta WPA e WPA2 (protocolos também
seguros de comunicação baseados no IEEE 802.1) e tem baixo consumo de energia. Possui um
regulador de tensão e, tal como o Blue Pill, opera em 3.3V, com pino com suporte para 5V
associado à alimentação microUSB.
É claro que o esse microcontrolador não é perfeito, afinal, não estamos trabalhando numa
linha progressiva de evolução dos microcontroladores. Embora estejamos, de fato, mostrando
opções alternativas que podem sim ser melhores ao uso do Arduino Uno, tanto para prototipagem
quanto para aplicação em mercado, devemos analisar cada uma das características que são
pertinentes a um dado projeto antes de decidirmos qual microcontrolador iremos utilizar.
A seguir, um comparativo entre os microcontroladores apresentados:
Tabela 4.
Especificações Técnicas ESP8266 STM32F103C8T6 Arduino UNO
Arquitetura 32 Bit 32 Bit 8 Bit
Velocidade processador 80MHz 72 MHz 16 MHz
Memória Flash 16 MB 64 kB 32 Kb
RAM 160 kB 20 kB 2 Kb
Alimentação 4.5 – 9V 2.5 - 5.5 V 7 – 12 V
Cristal RTC Não possui 32 kHz Não possui

SPI, I2C, UART, SPI, I2C, UART,
Tipos de barramento SPI, I2C, UART
I2S CAN
Pinos ADC 1 (10-bit) 10 (12-bit) 6 (10-bit)
GPIO's 17 37 14
Wi-Fi 802.11 b/g/n Não possui Não possui
235
7.1. Por que utilizar o ESP8266?
Uma das principais vantagens do microcontrolador consiste em possuir rede sem fio
integrada, o que a torna ideal para projetos em robótica e automação inicial. Diferentemente
de placas concorrentes (apresentados nesse livro ou não) que necessitam de complementos,
os módulos ou Shields, para conseguirem conectividade com uma rede com fio ou sem fio, o
ESP8266 traz nativamente capacidade de conectar-se com qualquer rede e,
consequentemente, com a Internet sem deixar de lado um porte compacto comparável ao
dos outros microcontroladores.
Além disso, ele já possui uma interface Micro USB deixando simples sua conexão com o
computador, podendo utilizar da mesma IDE que temos utilizado até o momento para a
programação e sem a necessidade de instalação de um grande número de softwares ou
modificações em seu bootloader para o funcionamento.
Tudo bastante simples e propício para a criação de novas aplicações com montagens
que já temos familiaridade, facilidade de acesso a uma rede de computadores e Internet,
ótima para associação à dispositivos móveis, além de sua programação específica para
criação de páginas web e troca de dados não necessitar de um entendimento profundo sobre
linguagens como o HTML.
Por fim, com todas esses facilidades de montagem e programação em rede, transmitir e
controlar ações via internet, de onde você estiver, não importando a distância, apenas
assegurando a existência de conectividade à rede global torna tudo mais interessante para
nós e para um possível negócio.
7.2. Utilizando o microcontrolador NodeMCU
Para o desenvolvimento dos nossos projetos, faremos uso da versão 3 do NodeMCU

ESP8266, também conhecido como LoLin. A placa faz uso do módulo Wi-Fi ESP-12E e, diferente
de versões anteriores, possui o chip para a comunicação USB para serial CH340. Caso ainda
não tenha instalado o driver que possibilita a comunicação do computador com o
microcontrolador, retorne para “1.10. Corrigindo problemas de conexão” onde uma breve
explicação é dada sobre o chip e como podemos instalar seu driver.
As dimensões da placa impedem que ela seja encaixada propriamente em um protoboard,
sendo necessário associar dois deles ou então utilizar jumpers para conectar os pinos de
interesse ao protoboard ou, ainda, comprar uma base adaptadora própria ao microcontrolador.
236
Figura 7.1. LoLin visto tanto de sua parte inerior, quanto de sua parte superior. Na parte inferior,
podemos identificar algumas informações iniciais básicas e necessárias para seu uso: instalar o
driver CH340, configurar a taxa de transmissão de dados e conectar-se a uma rede WiFi. Fonte:
http://projectshopbd.com/product/nodemcu-wifi-esp8266-development-board/, acesso em:
outubro, 2018.
Os protoboards mais comuns à venda possuem regiões de encaixe, tornando simples sua
associação para montagens de protótipos mais complexos ou, como no caso, para que
possamos encaixar facilmente o NodeMCU LoLin.
Figura 7.2. Regiões de encaixe entre protoboards. Ao encaixar dois protoboards, não temos
nenhuma ligação de seus conectores internos, apenas externamente, tornando mais simples e
estável o uso de multiplos elementos do mesmo.
237
Figura 7.3. Microcontrolador ESP8266 encaixado entre dois protoboards. Fonte:
https://42bots.com/esp8266/nodemcu-esp8266-iot-development-board-overview/. Acesso em:
outubro, 2018.
Figura 7.4. Base adaptadora própria para uso do NodeMCU LoLin. Fonte:
http://blogmasterwalkershop.com.br/embarcados/nodemcu/base-adaptador-para-o-nodemcu-v3-
da-lolin/. Acesso em: outubro/2018.
Já especificadas algumas informações sobre o microcontrolador na Tabela 11, nos resta

apresentar a pinagem do mesmo. Veja:
238
Figura 7.5. Esquema de pinagem do NodeMCU LoLin ESP8266.
Agora que já estamos um pouco mais familiarizados com as questões mais básicas sobre o
visual e pinagem do microcontrolador, partiremos para os passos necessários para realmente
podermos utilizá-lo.
Em primeiro lugar, temos a instalação do driver CH340, o qual permite a comunicação USB
para serial. Como já discutido, caso ainda não tenha instalado, retorne ao tópico 1.10 do material
para explicações de como baixar e instalar o driver de seu site de origem ou de um site
alternativo.
Em seguida devemos abrir o IDE do Arduino, acessar o menu “arquivo” > ”preferencias” e
colar a seguinte URL em “URLs adicionais de Gerenciadores de Placas”:
http://arduino.esp8266.com/stable/package_esp8266com_index.json.
Clicamos em ”OK” para finalizar, conforme imagem à seguir.
239
Figura 7.6. Devemos colar a URL e, em seguida, clicar em "OK" para finalizar a ação.
O próximo passo é acessar o Gerenciador de Placas em “Ferramentas” > ”Placa:”. Lá,

pesquisaremos por “esp8266 by ESP8266 Community”, intalando-o na sequência.
240
Figura 7.7. Localizando o esp8266, no Gerenciador de Placas, o qual devemos instalar para poder
utilizar os microcontroladores da familía.
A instalação do elemento permite o uso de módulos da família ESP8266, o que inclui o nosso
microcontrolador.
Voltando agora ao menu “Ferramentas” devemos selecionar a placa que permite o uso do
NodeMCU ESP8266. Como mencionamos, no início do capítulo, o microcontrolador é baseado
no módulo ESP8266-12E e, desse forma, devemos procurar esse módulo ao pesquisarmos a
placa que deve ser escolhida. Veja:
Figura 7.8. Módulo a ser selecionado para uso do nosso microcontrolador no Arduino IDE.
241
Finalmente temos tudo pronto utilizar, de fato, o Arduino IDE e construirmos algumas linhas
de código utilizando nosso microcontrolador.
7.3. Comunicação via Wi-Fi
O foco do LoLin NodeMCU é sua comunicação WiFi, como temos dito até aqui. Desse modo,
para ilustrar sua aplicação, a transferência de dados pela rede e como fazer o controle de uma
lâmpada faremos dois projetos: no primeiro, o microcontrolador será um WEB server
administrando uma rede local via WiFi; na segunda teremos um WEB client comunicando-se com
um servidor via Wi-Fi pela internet.
MONTAGEM DO SISTEMA
Para os dois projetos que serão mostrados, a montagem do sistema será a mesma. Porém
existem duas modos de energizar o microcontrolador e o relé que podem ser utilizadas e que
são importantes de serem mencionadas.
A primeira a ser apresentada é a mais simples, utilizando apenas do microcontrolador. Nela,
a placa é energizada via microUSB e o relé será diretamente associado à mesma.
Circuito
lâmpada
via microUSB
Alimentação
Figura 7.9. Montagem do circuito de controle de lâmpada utilizando NodeMCU LoLin. Aqui, a
alimentação deve ser feita através do conector microUSB.
242
A segunda forma utiliza uma fonte de energia externa que converte o sinal para 5V ou
3,3V e pode ser utilizada de acordo com as necessidades do microcontrolador e relé utilizado.
Figura 7.10. Módulo de alimentação YwRobot. Fonte:

http://wiki.sunfounder.cc/index.php?title=How_to_use_YwRobot_Power_Supply_Properly. Acesso
em out/2018.
Circuito
lâmpada
Alimentação
Figura 7.11. Montagem do circuito de controle de lâmpada utilizando NodeMCU LoLin. Aqui, a
alimentação deve ser feita através de um dos conectores (USB conector DC) do YwRobot.
243
WEB SERVER EM REDE LOCAL
Para a construção de um web server utilizaremos algumas funções básicas em HTML
para a criação da página web. Nessa página teremos 2 botões para podermos selecionar o
acionamento ou desligamento da lâmpada associada ao microcontrolador.
O microcontrolador será o responsável pela página e por atendem as requisições feitas
pela web sendo, portanto, o servidor (por isso a denominação de web server).
Ao microcontrolador devemos oferecer informações de nome (o SSID19) e senha para
acesso à uma rede WiFi, porta de comunicação (por onde e que tipo de comunicação será feita).
Após a inicialização da conexão à rede sem fio, será iniciado o servidor que, por sua vez, irá
atribuir dinamicamente um IP20 ao microcontrolador.
Feito isso, ao código fica a competência de verificar a existência de informações a serem
lidas (solicitações para o controle da lâmpada), identificar o que está sendo solicitado através da
leitura e identificação da informação recebida e apresentar respostas na página além de realizar
uma ação sobre o solicitado.
Dentro desse processo, o código também verifica se a solicitação foi realizada com
sucesso ou não, produzindo uma resposta dentro dos quatro quadrantes, como temos feito nos
outros projetos.
#include <ESP8266WiFi.h> //cabeçalho para uso do WiFi do NodeMCU LoLin
const int rele = 2; // Pino ligado ao relé - GPIO02 (pino D4)

const int analogPin = A0; //pino de leitura analogica do LDR
boolean status_lamp = false; // Variável para o status da lampada

int resposta;
const char* ssid = "nome_da_rede";

const char* password = "senha_da_rede";
WiFiServer server(80); //porta de comunicacao http
19 Service Set IDentifier (em português: identificação do conjunto de serviço) é uma string de até 32
caracteres que identifica uma rede sem fio.
20 Internet Protocol é um rótulo numérico utilizado para identificar um dado dispositivo em uma rede.
244
void setup() {
Serial.begin(115200); //taxa de transmissao de dados adequada para

//rede sem fio
delay(10);

}
// Verificação e conexão à rede

Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
//inicia a comunicação
WiFi.begin(ssid, password);
//enquanto não houver conexão

while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\n WiFi connected!");
// Inicia o servidor
server.begin();
Serial.println("Server started");
// Printa o endereço de IP
Serial.print("URL: ");
Serial.print("http://");
Serial.print(WiFi.localIP());
Serial.println("/");
245
void loop() {
DetectaLuzTempo();
// Checka por conexoes de cliente (ESP8266)

WiFiClient client = server.available();
if (!client) {
return;
}
// Espera até que algum dado seja encaminhados

Serial.println("new client"); //O esp estah aqui
while(!client.available()){ //e estamos aguardando que ele mande
//alguma coisa
delay(1);
}
// Lê a primeira linha da requisição

String leituraWifi = client.readStringUntil('\r');
Serial.println(leituraWifi);
client.flush();
// Verifica com qual requisição é encontrada uma combinação
if (leituraWifi.indexOf("/LED=ON") != -1) {
status_lamp = true;
delay(50);
}
if (leituraWifi.indexOf("/LED=OFF") != -1) {
delay(50);
}
// Retorna a resposta na página

client.println(""); // do not forget this one
client.println("<!DOCTYPE HTML>");
client.println("<html>");
246
client.print("Status da lampada: ");
if (status_lamp){ //para 2 quadrantes de acionamento

client.print("Comando Ligar, Luz Ligada");
else
client.print("Comando Ligar, Luz Desligada");
}
else{//para 2 quadrantes de desligamento

client.print("Comando Desligar, Luz Desligada");
else
client.print("Comando Desligar, Luz Ligada");
}
client.println("<br><br>");
client.println("<a href=\"/LED=ON\"\"><button>Turn On </button></a>");
client.println("<a href=\"/LED=OFF\"\"><button>Turn Off </button></a><br
/>");
client.println("</html>");
client.flush();
//libera para nova comunicação pela porta

Serial.println("Client disonnected");
Serial.println("");


//luminosidade após a inicial
247
if(digitalRead(rele) == LOW) //se a lampada estiver ligada, a atualização
//é um fator que pode perturbar a resposta real
else{
ambiente=0;
}
}
}
}
Não entraremos em detalhes acerca de códigos HTML, mas para que fique claro como
ele foi utilizado no nosso programa para o Blue Pill suas linhas serão destacadas sem o uso da
função client.println(), a qual é responsável por direcionar cada linha do código para a página
que será vista pelo cliente que solicita as ações a serem tomadas.
HTTP/1.1 200 OK
Content-Type: text/html
<!DOCTYPE HTML>
<html>
Status da lampada:
<br><br>
<a href=\"/LED=ON\"\"><button>Turn On </button></a>
<a href=\"/LED=OFF\"\"><button>Turn Off </button></a><br />
</html>
Os cabeçalhos HTTP sempre começam com um código de resposta, como o da primeira

linha. Ele significa que o servidor irá responder utilizando o protocolo HTTP em sua versão 1.1,
sendo “200 OK” um código de status inferindo que a requisição feita foi um sucesso.
Na segunda linha temos o tipo de conteúdo que esperasse que o cliente receba.
Essas linhas são omitidas na página quando o código estiver em funcionamento e as
linhas seguintes representam uma mensagem que será apresentada na tela e os botões. Quando
248
um botão for pressionado, a URL será complementada com “LED=ON” ou “LED=OFF” indicando
seu uso.
A nova URL também serve de base para obtenção de respostas e também como modo
de realizar a requisição, tendo em vista que escrevê-la em sua totalidade com uma das duas
respostas tem o mesmo efeito que clicar no botão.
Supondo que, ao iniciar o sistema, o IP do microcontrolador seja “192.168.43.196”, digitar
esse valor num browser conectado à mesma rede fará com que a página seja mostrada.
Figura 7.12. Página criada pelo servidor.
Clicar no botão, então, teria o mesmo efeito de digitarmos “192.168.43.196/LED=ON” ou

“192.168.43.196/LED=OFF”.
Uma das respostas dos quatro quadrantes deve aparecer após “Status da lâmpada: ”,
indicando o que ocorreu após a solicitação enviada.
Podemos também, caso seja de interesse, montar um aplicativo utilizando o AppInventor2
para que não precisemos digitar o IP no browser.
Embora a ação não seja nada complexa e poder ser realizada perfeitamente dessa
maneira em nosso projeto, talvez em algum projeto mais complexo seja mais usar o mínimo
possível de código HTML deixando toda a aparência para uma linguagem que já tornamos mais
familiar e sabemos de sua simplicidade.
No projeto atual, podemos facilmente reaproveitar o aplicativo desenvolvido na seção
“5.4. Comunicação via Ethernet e roteador” com modificações nas estruturas das Fig. 5.33, Fig.
5.37 e Fig. 5.38, adaptando as URL’s e as palavras a serem buscadas na página. Exercite seu
conhecimento e tente modificar os Blocks!
WEB CLIENT CONCECTANDO-SE AO SERVIDOR VIA INTERNET

Agora faremos o microcontrolador acessar uma página de um servidor web qualquer.
Para isso é necessário ter acesso a um domínio que possamos manipulá-lo e programa-lo.
249
Nesse projeto, mostraremos como realizar a captação dos dados de um LDR e como
acionar ou desligar uma lâmpada. O funcionamento conjunto ficará por sua conta para praticar o
que temos visto até aqui e para que possa aplicar seus conhecimentos.
Sendo o microcontrolador o cliente, ele encaminhará solicitações ao servidor e esse, por
sua vez, disponibilizará para o cliente uma resposta.
O servidor conta com uma página web em HTML com um código simples em PHP, uma
linguagem interpretada que será utilizada em um simples processamento de dados. Existem
várias linguagens que são passíveis de serem inseridas dentro de um documento HTML e são
uteis para a comunicação e tratamento de dados recebidos de um cliente.
Embora o intuito do material não seja detalhar as diversas formas de programação, é
importante saber de pelo menos dois métodos muito importantes na hora de desenvolver uma
página web, por mais simples que seja: GET e POST.
Posteriormente, seguiremos com a apresentação da página HTML utilizando PHP para,
então, continuarmos com a apresentação do código elaborado no arduino IDE.
Como já devem ter percebido, o HTTP foi desenvolvido de forma a possibilitar a
comunicação entre clientes e servidores sendo um tipo de protocolo que fornecesse respostas
atendendo às requisições feitas. Os métodos relacionados a esse protocolo são, assim,
referentes a forma em que essa comunicação ocorrerá.
O método GET é utilizado para solicitar algum dado de recurso específico e, ao
utilizarmos, os dados que solicitamos são atribuídos ao cabeçalho da requisição. Isso significa
que estes estarão visíveis na URL.
Sendo assim, ao criarmos uma página chamada “read.php” num dado servidor solicitando
que seja exibido nessa página um valor de leitura do LDR e sendo esse valor igual a “500”, uma
solicitação utilizando HTTP GET teria, por exemplo, o formato:
../read.php?valor=500
É importante saber sobre o método GET:

 Pode ser armazenado e favoritado (bookmark);
 Permanece no histórico;
 Por ser explicitado na URL, não deve conter informações que possam
comprometer o sistema como, senhas e outros dados que podem ser sigilosos ou
de relevância ao servidor/desenvolvedor;
 Possui uma restrição de tamanho (255 caracteres, de modo geral);
250
O método POST é mais indicado quando desejamos enviar informações que desejamos
processar para, por exemplo, criar ou atualizar um recurso. Por meio dele, os dados com as
solicitações que forem enviados ao servidor são armazenados no corpo da requisição HTTP:
POST /read.php?valor=500 HTTP/1.1
Host: siteHospedeiro.com
Valor=500
Sobre o método POST é importante saber:

 Não pode ser armazenado ou favoritado;
 Não permanecesse no histórico do browser;
 Não há uma restrição tão baixa quanto ao GET e suporta outros formatos de
informação que não de texto como imagens, por exemplo.
A página do servidor é como se segue abaixo. Os textos entre “” e entre “/* */”
são comentários, sendo as formas entre aspas uma maneira de realizar comentários em HTML
e em PHP. Tudo mais representa o código.

<html>

<h1>STATUS:</h1>
<?php /*Iniciando codigo em php*/
/*verifico existencia do arquivo status.txt, se nao existe cria-se com

valor de estado "false"*/
if(!file_exists("status.txt"))
file_put_contents("status.txt","<p>false</p>");
/*Criando variável com o paramento status recebido do GET, para pegamos

pelo post mudamos para $_POST*/
$pedido = $_GET["status"];
/*Se for true muda status para true, para ligar a lâmpada*/
if($pedido == "true") file_put_contents("status.txt","<p>true</p>");
/*se for false mude status para false, para deligar a lâmpada*/
if($pedido == "false") file_put_contents("status.txt","<p>false</p>");
$ler = file("status.txt"); /*abri status.txt*/
/*laco de leitura, ler todo file*/

foreach($ler as $ler){
/*exibir todo o file */
echo($ler);
251
$ler = file("status.txt"); /*abri status.txt*/
/*laco de leitura, ler todo file*/

foreach($ler as $ler){
/*exibir todo o file */
echo($ler);
}
/*pegar paramento valor*/

$valor = $_GET["valor"];
if(!file_exists("value.txt")) file_put_contents("value.txt","0");
/*verificar se foi passado um valor*/

if($valor != NULL) {
file_put_contents("value.txt", $valor);
}
$ver = file("value.txt");
echo("<h2>Valor: </h2>");
/*laço de leitura, ler todo o arquivo */

foreach($ver as $ver)
{
/*exibir todo o arquivo */
echo($ver);
}
/*fim do php*/
?>


</html>
Numa primeira execução do sistema, a pagina irá criar dois arquivos de texto
denominados “status.txt” e “value.txt” onde ficaram armazenados o status da lâmpada, que pode
ser “true” ou “false” e o valor de leitura do LDR. Nas solicitações subsequentes, esses arquivos
serão atualizados.
252
Os valores armazenados serão apresentados na página abaixo de seus respectivos
cabeçalhos (h1 e h2). A Fig. 7. Ilustra uma resposta para lâmpada desligada (“false”) e o valor
lido no LDR de “231”.
Figura 7.13. Página web com status para lampada desligada e leitura do LDR.
Note que, na imagem apresentada da página web, os dois parâmetros podem ser
passados ao mesmo tempo e o “&” é usado como um separador. No código do Arduino IDE, eles
serão repassados um à um, mas a forma mostrada agora pode servir de base para seu projeto
final de atuação em quatro quadrantes.
O código foi dividido em abas no ambiente de desenvolvimento e discutiremos
separadamente as partes secundárias para depois esclarecermos o corpo principal (contendo
“setup()“e o “loop()”).
253
void conectar(){
Serial.begin(115200); /*na conexao WiFi, a taxa de transmissao de dados
eh diferente*/
delay(10);
// Inicio da conexao WiFi com prints no Serial Monitor
Serial.println();
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password); /*funçao que realmente inicia a comunicaçao
WiFi*/
/*loop apenas para informar que estah ocorrendo tentativa de conexao ou

que o wifi foi conectado*/
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("\n WiFi connected!");
}
A aba da função “conectar()” contem nada mais que os passos que envolvem a conexão
serial (para verificar alguma informação desejada) e com uma rede sem fio.
254
void verificar_status(){
WiFiClient client;
const int httpPort = 80;
if (!client.connect(host, httpPort)) {
Serial.println("connection failed");
return;
}
//acessa o WebServer, sem mandar novas informaçoes, utilizando GET

String url = "/pedro/read.php";
client.print(String("GET ") + url + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Connection: close\r\n\r\n");
/*verifica se o cliente nao estah a mais de 5 seg. ocupando o canal de

comunicaçao, caso esteja, ocorre timeout*/
unsigned long timeout = millis();
while (client.available() == 0) {
if (millis() - timeout > 5000) {
Serial.println(">>> Client Timeout !");
client.stop();
return;
}
}
/*faz a mesma verificaçao do status solicitado ao led
o controle do led serah feito diretamente digitando:
http://erradica.com.br/pedro/read.php?status=true ou
http://erradica.com.br/pedro/read.php?status=false */
while (client.available()) {
String line = client.readStringUntil('\r');
Serial.println(line);
if (line.indexOf("true") != -1)
{
stat = true;
}
if (line.indexOf("false") != -1)
{
stat = false;
}
}
}
255
A função “verificar_status()” será utilizada para fazer a verificação na página web do
servidor. Nessa página, uma busca será feita para a string “true” ou “false” que representam a
solicitação de acionamento ou desligamento. O valor é armazenado na variável “stat”, declarada
na aba principal do código e onde, também, será tratada para realizar a ação solicitada.
Para isso, um cliente é criado para se conectar ao host21 através de uma porta de
comunicação. Isso é feita pela função “cliente.connect()” cujos argumentos são o IP ou nome no
DNS22 do servidor hospedeiro da página e a porta de comunicação.
Foi elaborada também uma rotina para liberar o acesso utilizado pelo cliente caso não
seja dada uma resposta após cinco segundos. A requisição é feita utilizando HTTP GET.
A terceira aba criada contém a função “GET(int valor)”, muito semelhante à anterior por
verificar o conteúdo de uma página web, porém, com algumas modificações.
Enquanto “verificar status()” complementa com “/pedro/read.php” a URL do host, essa
outra função também solicita que seja apresentado na página o valor lido referente ao LDR.
Assim, a URL com “/pedro/read.php?valor=” tem, na sequencia, o valor de leitura.
void GET(int valor)

{
WiFiClient client; //cria o objeto client da classe WiFiClient
const int httpPort = 80; //porta de acesso ao host
//verifica se o cliente foi conectado ao host pela porta de comunicaçao

if (!client.connect(host, httpPort)) {
Serial.println("connection failed");
return;
}
/*caso seja feito a conexao, complementaremos o caminho da pagina do

host*/
String url = "/pedro/read.php?valor="; /*esse complemento possibilita
adquirir o valor do LDR pela pagina no código em php (ver codigo)*/
21 Também chamado de hospedeiro é aquele que pode oferecer informações recursos, serviços e
aplicações para um cliente ou outros servidores. No caso, o host que será utilizado é um site de domínio
criado e sustentado por um dos autores do livro (por tempo indeterminado).
22 Domain Name System (ou Sistemas de Nomes de Domínios) são responsáveis por listar, localizar e
traduzir para números de IP os nomes de domínios. A transformação dos IP’s em URL’s mais facilmente
memorizáveis facilita o acesso do usuário a um dado domínio.
256
Serial.print("Requesting URL: ");
Serial.print(url);
Serial.println(valor);
//uso da requisiçao GET incluindo envio de dados pela URL

client.print(String("GET ") + url + valor + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Connection: close\r\n\r\n");
//Verifica timeout
unsigned long timeout = millis();
while (client.available() == 0) {
if (millis() - timeout > 5000) {
Serial.println(">>> Client Timeout !");
client.stop();
return;
}
}
/*verifica a pagina e le ateh \r, buscando por uma resposta fornecida

pelo codigo php (ligar/desligar lampada)*/
while (client.available()) {
String line = client.readStringUntil('\r');
if (line.indexOf("true") != -1)
{
stat = true;
}
if (line.indexOf("false") != -1)
{
stat = false;
}
}
}
Por fim, temos a seguir a parte principal que une todo o código para seu funcionamento.
Isso trará clareza no papel de cada função.
257
#include <ESP8266WiFi.h> /*Inclusão do cabeçalho para biblioteca de wifi
do microcontrolador*/
const char* ssid = "nome_da_rede";

const char* password = "senha_da_rede";
const char* host = "www.erradica.com.br"; /*DSN que referencia o endereço
do WebServer*/
//"stat" e "anRead" serão variáveis de teste

boolean stat = false; //referente ao estado do LED do circuito
int anRead = A0; /*referente ao pino analógico no ESP, no qual foi ligado
um LDR (apenas para testes de alteração de valor)*/
void setup() {
pinMode(15,OUTPUT); /*pino digital D7 (GPIO_15) -> podemos trocar o
valor do GPIO pelo nome do pino: (pinMode(D7, OUTPUT)) */
conectar(); //função para conectar a comunicação serial e wifi

}
void loop() {
/*Criamos uma variável para testar a leitura do LDR quando enviássemos

"v" para o Serial Monitor*/
char LDR = Serial.read();
if (LDR == 'v'){
int leitura = analogRead(anRead); /*armazenamos a leitura analógica em
"leitura"*/
delay(250);
GET(leitura); /*enviamos o valor como argumento dessa funçao que fará
uma requisição usando método GET*/
}
/*se não estivermos testando LDR, será feita uma verificação constante
do que está sendo carregado na página do Web Server */
else{
verificar_status();
}
/*ao final, verificamos o status do led (desligado, por padrão do código

PHP */
if(stat) digitalWrite(15, HIGH);
else digitalWrite(15, LOW);
}
258
O funcionamento completo do sistema é como se segue:
 Informamos o nome da rede, sua senha e o host no qual desejamos nos conectar;
 Caso tudo seja bem sucedido, a conexão com a rede sem fio é estabelecida;
 Verifica-se o interesse na informação de leitura do LDR;
 Sendo de interesse, “GET(int valor)” é iniciado e a URL é criada e encaminhada
pela porta de comunicação sendo o valor lido apresentado na tela. Também é
verificado se, nesse meio tempo, também foi solicitado uma ação para controle da
lâmpada;
 Caso não seja de interesse, entraremos na função “verificar_status()”;
 Por fim, é a variável responsável pelo controle da lâmpada é tratada afim de saber
qual ação deve ser tomada;
 O controle da lâmpada é feito por meio do browser através de duas URL’s, as
quais foram apresentadas no código do sistema (um aplicativo pode ser elaborado
no AppInventor2).
A página fornecida em “host” é um domínio pertencente a um dos autores desse

material. Para fazer a hospedagem de um site existem diversos provedores tal como, por
exemplo, o Hostgator (site de hospedagens no qual o domínio foi criado).
Para uma aplicação pessoal com site próprio que possa ser programado para gerar
páginas de acordo com seu interesse existem sites, pagos e gratuitos que podem lhe oferecer
essa facilidade.
Além disso, existe um outro método que pode ser utilizado, porém não recomendável,
para acessar e controlar um sistema denominado port fowarding. A técnica deixa uma porta
da rede visível para além do modem e de firewalls de proteção, tornando o sistema vulnerável
a ataques e possível comprometimento pessoal, dependendo das circunstancias. Devido a
essas questões e ao fato de que alguns mecanismos de proteção impossibilitam o uso de
port fowarding a ideia não será explorada.
Por fim, é possível, sem a necessidade de adquirir um domínio, utilizar sites cuja
proposta de IoT facilita a implementação em nuvem para controle a distância. No tópico
seguinte, explicaremos sobre os primeiros passos necessários para o uso de uma dessas
plataformas.
259
7.4. Comunicação pela nuvem utilizando aREST
A plataforma aREST foi desenvolvida para fornecer soluções de IoT que se baseiam em
Arduino e Raspberry Pi. Ela utiliza um estilo de arquitetura denominada REST (Representational
State Transfer) o qual é baseado em HTTP.
Um serviço de web RESTful (que tem arquitetura REST), além de possibilidade operações
entre sistemas através da internet, tem características conceituais que vão de encontro com o
que vemos apresentado até aqui: o uso de protocolo cliente-servidor e o uso de operações para
a manutenção de recursos, tais como GET e POST.
Na aREST temos a possibilidade de uso gratuito, que fornece todo o conteúdo de uso
suficiente para a montagem dos nossos projetos, mas também podemos realizar um pagamento
mensal aumentando a capacidade de uso dos recursos conforme a necessidade do conteúdo for
ampliada.
UTILIZANDO O AREST NO ARDUINO

Como a plataforma foi desenvolvida para a elaboração de projetos utilizando
microcontroladores a mesma disponibiliza de uma biblioteca a qual deve ser instalada para uso
no Arduino IDE.
De modo simples, podemos acessar o “Sketchs>Incluir Biblioteca>Gerenciar
Bibliotecas...” para pesquisar a biblioteca de interesse, digitando “arest” na barra de pesquisa.
Figura 7.14. Caminho para o Gerenciador de Bibliotecas.
260
Figura 7.15. Biblioteca aREST a ser instalada.
Além disso, precisamos adicionar uma biblioteca para uso do protocolo de comunicação
MQTT (Message Queuing Telemetry Transport), o qual está implementado no servidor em nuvem
do aReset.
O MQTT é um protocolo de mensagens leves e, embora simples, contempla aspectos de
segurança e qualidade de serviço, sendo facilmente implementado em um sistema e o tornando
ideal para muitos projetos IoT. Dessa forma, se é possível que o servidor utilizado tenha tal
protocolo como base, a comunicação será eficiente para o uso de sistemas embarcados.
No Gerenciador de Bilbiotecas, devemos procurar por “PubSubClient”, de Nick O’Leary,
e instalar a biblioteca.
Figura 7.16. Devemos instalar a biblioteca PubSubClient, de Nick O’Leary.
261
Para garantir o funcionamento das bibliotecas instaladas, reinicie o IDE após a conclusão
dos procedimentos. Feito isso, iremos utilizar um dos exemplos de aplicação em nuvem
acessando “Arquivo>Exemplos>aREST>ESP8266_cloud”.
Figura 7.17. Caminho para exemplo de uso de um sistema NodeMCU LoLin em nuvem.
Quando formos utilizar o código, devemos fazer duas alterações básicas.

A primeira é a definição do nome da rede e a senha, algo que já viemos fazendo ao longo
de projetos anteriores.
// WiFi parameters
const char* ssid = "your_wifi_network_name"; //mude para sua rede
const char* password = "your_wifi_network_password";//senha sua rede
A segunda, que na verdade aparece primeiro no sketch, é a identificação do dispisitivo.

O nome atribuído a esse identificador será solicitado no painel de controle (dashboard, em inglês)
do aREST, quando formos montar a página que utilizaremos no sistema de acionamento.
262
// Unique ID to identify the device for cloud.arest.io
char* device_id = "unique_device_id";
O uso de variáveis e de funções não será explorado no momento. O exemplo que será
passado nesse tópico será o do simples acionamento de um relé, porém, você pode acessar à
plataforma onde todas as informações sobre a biblioteca da aREST pode ser encontrada
(https://github.com/marcoschwartz/aREST), inclusive com algumas informações de uso (em
README). Faça isso e exercite suas capacidades para o desenvolvimento do sistema utilizando
os quatro quadrantes.
UTILIZANDO A AREST
Ao acessar o site da aREST (https://arest.io/), o primeiro passo é clicarmos em “Get
Started”.
Figura 7.18. Recorte da página inicial do site aREST. Aqui, devemos clicar em "Get Started" ao fazer
o primeiro acesso.
Na página que será aberta (https://arest.io/get-started) são apresentadas informações

gerais da aREST, instruções básicas para mudança de estado de um pino digital (para HIGH) e
a mensagem passada pelo servidor quando a ação é realizada, além do botão “Get Your
Personalised Tutorial” o qual possibilita, pela resposta de algumas perguntas rápidas e
informação do seu e-mail, receber um tutorial específico para sua plataforma de interesse.
Para mudar o estado do pino digital 6 do Arduino para nível alto (HIGH) a página informa
que precisamos informar à nuvem da Arest o “device_id”, se o tipo de pino (digital), o seu número
(6), e o estado que queremos (“1”, para HIGH e “0”, para LOW) da seguinte maneira:
cloud.arest.io/my_device/digital/6/1
263
Figura 7.19. Recorte da página "get started" com algumas informações sobre mudança de estado
do pino e o botão do tutorial personalizado.
Figura 7.20. Primeira pergunta para acessar tutorial personalizado.
264
Figura 7.21. Segunda pergunta para acessar tutorial personalizado.
Figura 7.22. Solicitação de e-mail para aquisição do tutorial personalizado.
Parece receber um tutorial sobre automação residencial utilizando o ESP8266, devemos

selecionar “ESP8266/ESP32”, na Fig. 7.20, e depois “Home Automation”, na Fig. 7.21. Por fim,
informaremos um e-mail e clicaremos em “Get Your Personalised Tutorial”, na Fig. 7.22.
O tutorial de automação residencial para ESP8266 pode ser consultado no Anexo IV
Para obter acesso ao painel de controle, de onde faremos as configurações de uma

página web para controle do sistema, devemos clicar na parte superior do site em “Princing”. Na
página que será aberta (https://arest.io/pricing) iremos verificar três possibilidades de aquisição
de acesso à nuvem: a primeira gratuita (“Free Plan”) e duas mediante pagamento de valores
(“Hobbyist Plan” ou “Developer Plan”).
Como estamos iniciando nosso aprendizado sobre a plataforma clicaremos no botão
“CREATE AN ACCOUNT” de “Free Plan”.
265
Figura 7.23. Parte superior do site da Arest. Devemos clicar em "Pricing" para prosseguir com a
aquisição de acesso.
Figura 7.24. Recorte da pagina de criação de contas. Devemos escolher "Free Plain", para utilizar a
versão gratuita.
Preencha os campos necessários de cadastro e clique em “Sign Up”.
Figura 7.25. Informações solicitadas para criação de conta. Após preencher os campos, devemos
clicar em "Sign Up".
266
Caso tudo tenha sido corretamente preenchido, após a assinatura, a seguinte tela
aparecerá (Fig. 7.26) e um e-mail será enviado com um recibo de pagamento (mesmo para o
acesso gratuito).
Figura 7.26. Tela apresentada após clicar em "Sign Up".
Num outro e-mail, seremos informados do site para acesso ao painel de controle
(https://dashboard.arest.io/) no qual devemos realizar nosso acesso.
Figura 7.27. Parte superior do site do painel de controle (dashboard) aREST. Devemos clicar em
"Login" no canto superior direito.
Informe seus dados e clique no botão azul “Login”, para acessar.
267
Figura 7.28. Dados solicitados para acesso ao dashboard.
Estamos, finalmente, na área onde criaremos nossos painéis para o controle do nosso
sistema.
Como faremos um acionamento simples, tudo que precisamos é repassar as informações
do pino que desejamos manipular. Assim, considerando nossa última montagem, utilizaremos o
pino digital 2 (GPIO_02), ou seja, o pino D4.
Devemos clicar em “Add a New Dashboard” e, na sequência, fornecer um nome.
Figura 7.29. Pagina inicial do dashboard. Devemos clicar em "Add a New Dashboard".
Figura 7.30. Janela aberta para escolha de um título a ser dado ao dashboard.
Dado um nome como, por exemplo, “Lamp_Control”, devemos na sequencia clicar em

“Add a new dashboad”. Iremos verificar que um dashboard foi criado ao fundo.
268
Como precisaremos de apenas um, clicaremos no “x” no canto superior direito para que
possamos acessar o dashboard criado.
Figura 7.31. Tela após a criação do primeiro dashboard.
Ao clicarmos no nome do nosso dashboard, poderemos iniciar as modificações

necessárias no mesmo. Caso queiramos descará-lo, devemos clicar no botão vermelho com o
símbolo de lixeira.
Ao entrar em “Lamp_Control”, devemos clicar em “Show Edit Mode”, no canto superior
direito, e adicionar uma linha (“Add Row”) e uma coluna (“Add Column”). Podemos atribuir à
coluna um tamanho relativo à tela e, aqui, escolheremos 100%.
Figura 7.32. Recorte do canto superior direito, onde devemos clicar em "Show Edit Mode" para
iniciar a edição da página.
Figura 7.33. Recorte do dashboard. Devemos clicar em "Add Row".
269
Figura 7.34. Recorte do dashboard ao clicarmos em "Add Row". Devemos clicar no botão de mesmo
nome para adicionar uma linha na pagina e, em seguida, fecharmos a janela.
Figura 7.35. Adicionada a linha um botão dentro da linha será apresentado para adicionarmos uma
coluna (“Add Column”).
Figura 7.36. Podemos escolher o tamanho da coluna entre os valores de 25, 50, 75 e 100%.
Selecionado, devemos clicar em "Add Column" e fechar a janela.
Adicionada a linha e a coluna, um novo botão aparecerá para que possamos adicionar
um elemento (“Add Element”). Ao clicamos nele, uma janela será aberta e, nela, poderemos
escolher o tipo de elemento que desejamos adicionar à página, dar um nome ao mesmo e
informar o identificador de dispositivo, que associará o elemento com o dispositivo que
desejamos controlar.
270
Figura 7.37. Recorte da página com visão após adição de uma linha e uma coluna. Podemos agora
adicionar um elemento ("Add Element").
Como desejamos realizar um acionamento do último projeto que elaboramos, o tipo

(“Type”) de elemento desejado deverá ser “On/Off Button”, um botão para ligar e desligar. Para
identificar o pino que estamos utilizando, daremos ao elemento o nome (“Name”) de GPIO_02 e,
para identificar nosso microcontrolador (“Device ID”), str2018.
Lembrando que devemos também alterar o nome do “device_id” no nosso Sketch:
// Unique ID to identify the device for cloud.arest.io
char* device_id = "str2018";
Figura 7.38. Ao clicarmos para adicionar um elemento, devemos escolher seu tipo ("Type"), seu
nome "Name" e o ID do dispositivo a ser controlado ("Device ID").
Preenchidos os campos, devemos clicar em “Add Element” e fechar a janela. Em seguida,

clicaremos no botão “Edit Element”, adicionado após a adição do elemento que criamos, para
configurarmos o novo campo com a indicação do pino (“Pin”) que será utilizado pelo elemento
para controle do sistema.
271
Ao clicarmos em “Submit”, a configuração será adicionada e, ao fecharmos a janela,
teremos terminado as configurações de uso necessárias.
Figura 7.39. Recorte com visão do elemento criado. Devemos agora editá-lo ("Edit Component")
para adicionar a informação do pino que tal elemento representará.
Figura 7.40. Visão da janela de edição do elemento. Uma nova opção foi criada e, nela, devemos
selecionar o pino que utilizaremos para o controle do sistema.
Podemos agora ocultar os parâmetros de edição, deixando na tela apenas os botões

criados, ao clicarmos em “Hide Edit Mode” no canto superior direito da tela.
272
Figura 7.41. Recorte do canto superior direito da tela, onde é encontrado o botão "Hide Edit Mode".
O botão ocultará os elementos de edição, deixando apenas os botões criados.
O nosso dashboard “Lamp_Control”, finalizado, é como apresentado na Fig. 7.42. O

retângulo “N/A” guarda a informação de conexão, e terá seu nome alterado para “online ”quando
o código for carregado ao nosso NodeMCU LoLin, executado e realizar conexão com a nuvem.
Figura 7.42. Recorte do dashboard finalizado e com o modo de edição ocultado.
Ao carregarmos o código no microcontrolador, devemos abrir o Serial Monitor e resetar a

placa. Verificaremos a seguinte mensagem, conforme Fig. 7.43, que indica a conexão do a
nuvem da aREST.
Figura 7.43. Mensagem do Serial Monitor indicando conexão com a nuvem.
Também iremos observar, com a atualização do dashboard, a modificação da mensagem

de “N/A” para “online”.
Figura 7.44. Alteração de status de conexão no dashboard.
273
Basta agora clicarmos em “On” e em “Off”, para realizar o acionamento e desligamento
do relé23. Com isso, finalizamos os testes utilizando a plataforma aREST e deixamos aos leitores
o exercício de aplicação dos quatro quadrantes, como discutido anteriormente.
23Há um limite de uso da nuvem para algumas operações de acordo com o plano escolhido. Verifique sua
cota em “Account”, no canto superior esquerdo do dashboard.
274
8. Microcontroladores nos dias de hoje
Placas utilizando microcontroladores estão espalhadas por todas as partes e coisas no

mundo nos dias de hoje. Independente da arquitetura, tamanho, capacidade de processamento,
dentre outras características, projetos de engenharia e para hobbiestas utilizando algum modelo
estão em elevado uso, movendo um mercado de bilhões de dólares.
O Arduino UNO e suas variações, são uma escolha interessante para estudantes elaborarem
projetos experimentais em suas escolhas, universidades e até mesmo em casa. Porém, como
mostramos nesse livro, outras placas microcontroladas surgiram no mercado com capacidades
superiores a certos modelos Arduino e cobrindo melhor e com menor custo financeiro focos de
interesse em diversas áreas, não só de automação residencial.
O ESP32, um modelo mais avançado que o ESP8266 e não abordado nesse material é um
exemplo de que, com o crescimento do uso, diversos outros modelos de mercado têm surgido e
sendo potentes e superiores concorrentes de outras placas. As características dessa placa são
apresentadas na tabela a seguir.
Embora esse e outros modelos não tenham sido abordados aqui, alguns deles são capazes
de interagir com a IDE do Arduino (como o ESP32 citado) e, mesmo que não sejam, temos agora
um conhecimento inicial como ponto de partida para a elaboração de projetos ainda mais
elaborados utilizando microcontroladores e seus ambientes de desenvolvimento.
Explore, teste e procure sempre acompanhar o que há de novo e melhor se adequa ao seu
estilo, trabalho ou interesses futuros no mundo da tecnologia!
275
9. ANEXOS
Anexo I – Tabela de Modelos de Arduino e suas Especificações
Arduino Especificações Técnicas
Microcontroller ATmega328
Operating Voltage 5V
UNO Input Voltage (recommended) 7-12V
Input Voltage (limits) 6-20V
14 (of which 6 provide PWM
Digital I/O Pins
output)
Analog Input Pins 6
DC Current per I/O Pin 40 mA
DC Current for 3.3V Pin 50 mA
32 KB (ATmega328) of which
Flash Memory
0.5 KB used by bootloader
SRAM 2 KB (ATmega328)
EEPROM 1 KB (ATmega328)
Clock Speed 16 MHz
Microcontroller ATmega32u4
Input Voltage
LEONARDO 7-12V
(recommended)
Digital I/O Pins 20
PWM Channels 7
Analog Input
12
Channels
DC Current per I/O
40 mA
Pin
DC Current for 3.3V
50 mA
Pin
32 KB (ATmega32u4) of which 4 KB
Flash Memory
used by bootloader
SRAM 2.5 KB (ATmega32u4)
EEPROM 1 KB (ATmega32u4)
Clock Speed 16 MHz
276
Microcontroller AT91SAM3X8E
Operating Voltage 3.3V
Input Voltage
7-12V
(recommended)
DUE Input Voltage (limits) 6-16V
Digital I/O Pins
output)
Analog Input Pins 12
Analog Outputs Pins 2 (DAC)
Total DC Output
130 mA
Current
on all I/O lines
DC Current for 3.3V
800 mA
Pin
DC Current for 5V Pin 800 mA
512 KB all available for the user
Flash Memory
applications
SRAM 96 KB (two banks: 64KB and 32KB)
Clock Speed 84 MHz
Length 101.52 mm
Width 53.3 mm
Weight 36 g
Input Voltage 5V
Digital I/O Pins 20
PWM Channels 7
Analog Input
12
Channels
DC Current per I/O
40 mA
YUN Pin
DC Current for 3.3V
50 mA
Pin
32 KB (of which 4 KB used by
Flash Memory
bootloader)
SRAM 2.5 KB
EEPROM 1 KB
Clock Speed 16 MHz
Linux microprocessor
Processor Atheros AR9331
Architecture MIPS @400MHz
Ethernet IEEE 802.3 10/100Mbit/s
WiFi IEEE 802.11b/g/n
USB Type-A 2.0 Host
Card Reader Micro-SD only
RAM 64 MB DDR2
Flash Memory 16 MB
PoE compatible
802.3af card support
Length 73 mm
Width 53 mm
Weight 32 g
277
Microcontroller Atmel ATmega32u4

Clock Speed 16 MHz
Flash Memory 32 KB (ATmega32u4)
Digital I/O Pins (5V logic) 14
TRE PWM Channels (5V logic) 7
Analog Input Channels 6 (plus 6 multiplexed on 6 digital
pins)
Processor Texas Instrument Sitara
AM3359AZCZ100
(ARM Cortex-A8)
Clock Speed 1 GHz
SRAM DDR3L 512 MB RAM
Networking Ethernet 10/100
USB port 1 USB 2.0 device port, 4 USB 2.0
host ports
Video HDMI (1920x1080)
Audio HDMI, stereo analog audio input
and output
Digital I/O Pins (3.3V 23
logic)
PWM Channels (3.3V 4
logic)
MicroSD card
Support LCD expansion
conector
ZERO
ATSAMD21G18, 48pins
Microcontroller
LQFP
14, with 12 PWM and
Digital I/O Pins
UART
Analog Input Pins 6, 12-bit ADC channels
Analog Output
1, 10-bit DAC
Pins
DC Current per I/O
7 mA
Pin
Flash Memory 256 KB
SRAM 32 KB
EEPROM up to 16KB by emulation
Clock Speed 48 MHz
278
Input Voltage
7-12V
(recommended)
Digital I/O Pins 20
MICRO PWM Channels 7
Analog Input Channels 12
32 KB (ATmega32u4) of
Flash Memory which 4 KB used by
bootloader
Clock Speed 16 MHz
Length 48 mm
Width 18 mm
Weight 13 g
ESPLORA Microcontroller ATmega32u4

32 KB of which 4 KB
Flash Memory
used by bootloader
SRAM 2.5 KB
EEPROM 1 KB
Clock Speed 16 MHz
Input Voltage
7-12V
(recommended)
MEGA ADK Input Voltage (limits) 6-20V
54 (of which 15 provide
Digital I/O Pins
PWM output)
256 KB of which 8 KB used
Flash Memory
by bootloader
SRAM 8 KB
EEPROM 4 KB
Clock Speed 16 MHz
USB Host Chip MAX3421E
279
Input Voltage Plug
7-12V
(recommended)
Input Voltage Plug (limits) 6-20V
Input Voltage PoE (limits) 36-57V
Digital I/O Pins
output)
ETHERNET 10 to 13 used for SPI
4 used for SD card
Arduino Pins reserved:
2 W5100 interrupt (when
bridged)
Analog Input Pins 6
32 KB (ATmega328) of
Flash Memory which 0.5 KB used by
bootloader
SRAM 2 KB (ATmega328)
EEPROM 1 KB (ATmega328)
Clock Speed 16 MHz
W5100 TCP/IP Embedded
Ethernet Controller
Power Over Ethernet
ready Magnetic Jack
Micro SD card, with active
voltage translators
Input Voltage 7-12V
(recommended)
MEGA 2560 Input Voltage (limits) 6-20V
Digital I/O Pins 54 (of which 15 provide PWM
output)
Flash Memory 256 KB of which 8 KB used
by bootloader
SRAM 8 KB
EEPROM 4 KB
Clock Speed 16 MHz
280
Microcontroller Atmega32u4
Input Voltage 5V through flat cable
Digital I/O Pins 5
PWM Channels 6
Analog Input Channels 4 (of the Digital I/O pins)
Analog Input Channels
8
(multiplexed)
ROBOT DC Current per I/O Pin 40 mA
32 KB (Atmega32u4) of
bootloader
SRAM 2.5 KB (Atmega32u4)
EEPROM (internal) 1 KB (Atmega32u4)
EEPROM (external) 512 Kbit (I2C)
Clock Speed 16 MHz
Keypad 5 keys
potentiomenter attached to
Knob
analog pin
Full color LCD over SPI communication
SD card reader for FAT16 formatted cards
Speaker 8 Ohm
provides deviation from the
Digital Compass geographical north in
degrees
I2C soldering ports 3
Prototyping areas 4
Input Voltage 7-9 V
MINI Digital I/O Pins 14 (of which 6 provide PWM
output)
Analog Input Pins 8 (of which 4 are broken out
onto pins)
Flash Memory 32 KB (of which 2 KB used
by bootloader)
SRAM 2 KB
EEPROM 1 KB
Clock Speed 16 MHz
Length 30 mm
Width 18 mm
281
Microcontroller Atmel ATmega168 or

ATmega328
Operating Voltage (logic 5V
level)
Input Voltage 7-12 V
(recommended)
Input Voltage (limits) 6-20 V
NANO Digital I/O Pins 14 (of which 6 provide PWM
output)
Analog Input Pins 8
Flash Memory 16 KB (ATmega168) or 32
KB
(ATmega328) of which 2 KB
used by bootloader
SRAM 1 KB (ATmega168) or 2 KB
(ATmega328)
EEPROM 512 bytes (ATmega168) or
1 KB (ATmega328)
Clock Speed 16 MHz
Dimensions 0.73" x 1.70"
LILYPAD SIMPLES
Operating Voltage 2.7-5.5 V
Input Voltage 2.7-5.5 V
Digital I/O Pins
output)
Analog Input Pins 4
32 KB (of which 2 KB used
Flash Memory
by bootloader)
SRAM 2 KB
EEPROM 1 KB
Clock Speed 8 MHz
282
LILYPAD SIMPLES SNAP
Digital I/O Pins
output)
Analog Input Pins 4
Flash Memory
by bootloader)
SRAM 2 KB
EEPROM 1 KB
Clock Speed 8 MHz
Radius
18 mm
LILYPAD
ATmega168V or
Microcontroller
ATmega328V
Digital I/O Pins
PWM output)
Analog Input Pins 6
Flash Memory
by bootloader)
SRAM 1 KB
EEPROM 512 bytes
Clock Speed 8 MHz
LILYPAD USB
Input Voltage 3.8V to 5V
Digital I/O Pins 9
PWM Channels 4
Analog Input Channels 4
32 KB (ATmega32u4) of
bootloader
Clock Speed 8 MHz
283
3.3V or 5V (depending on
Operating Voltage
PRO MINI model)
3.35 -12 V (3.3V model) or 5 -
Input Voltage 12
V (5V model)
Digital I/O Pins
output)
Analog Input Pins 8
16 KB (of which 2 KB used by
Flash Memory
bootloader)
SRAM 1 KB
EEPROM 512 bytes
8 MHz (3.3V model) or 16 MHz
Clock Speed
(5V model)
Microcontroller ATmega328P
Input Voltage 3.35 -12 V
FIO Input Voltage for Charge 3.7 - 7 V
Digital I/O Pins
PWM output)
Analog Input Pins 8
Flash Memory
by bootloader)
SRAM 2 KB
EEPROM 1 KB
Clock Speed 8 MHz
ATmega168 or
PRO Microcontroller
ATmega328
Operating Voltage 3.3V or 5V
3.35 -12 V (3.3V versions)
Input Voltage
or 5 - 12 V (5V versions)
Digital I/O Pins
output)
Analog Input Pins 6
16 KB (ATmega168) or
32KB
Flash Memory
(ATmega328) of which 2 KB
used by bootloader
1 KB (ATmega168) or 2 KB
SRAM
(ATmega328)
512 bytes (ATmega168) or
EEPROM
1 KB (ATmega328)
8 MHz (3.3V versions) or 16
Clock Speed
MHz (5V versions)
284
Anexo II – Modelos de Shields para Arduino
GSM Ethernet
Wireless SD
WiFi Shield
USB Host Wireless Proto
285
Motor Proto
Sensor – Corrente,Tensão e Potencia

Ethernet Wifi Rs232
Joystick Infra Red (IR)
286
Anexo III – Datasheets relevantes
287
288
289
290
291
292
293
294
295
296
297
298
299
Anexo IV – Exemplo de Automação Residencial utilizando ESP8266 e aREST Cloud
Control Your ESP8266 Projects from

Anywhere Using aREST
by Marco Schwartz of aREST.io

https://arest.io/
I love to build Internet of Things projects, especially with the amazing ESP8266 WiFi chip.
However, it can be a bit tricky to get started, as you might feel lost in front of all the options that
are available to you when choosing a platform/framework to control your projects from the cloud.
This is why I created the aREST platform: to give everyone a free, easy to use, no registration
required platform that can be used for all your Internet of Things projects. And in this guide, I will
show you exactly how to use the aREST platform to control your ESP8266 projects from
anywhere in the world.
Hardware & Software Requirements

You will need an ESP8266 board, like the Adafruit Feather ESP8266 board that was used for
this guide. You will also need one LED, one 330 Ohm resistor, a breadboard, and some jumper
wires.
This is a list of all the components that will be used in this project:
● Adafruit Feather ESP8266 WiFi board

● LED
● 330 Ohm resistor
● Breadboard
● Jumper wires
On the software side, you will need the latest version of the Arduino IDE that you can get from:
http://www.arduino.cc/en/Main/Software
300
Then, follow this procedure to add the ESP8266 board to the Arduino IDE:
● Start the Arduino IDE and open the Preferences window.

● Enter the following URL into the Additional Board Manager URLsfield:
http://arduino.esp8266.com/package_esp8266com_index.json
● Open Boards Manager from Tools > Board menu and install the esp8266 platform.
You will also need the PubSub library that you can get from the Arduino library manager.
Hardware Configuration
Simply start by placing the ESP8266 board on your breadboard.
For the LED, simply connect it in series with the resistor, with the longest pin of the LED
connected to the resistor. Then, connect the remaining pin of the resistor to pin 5 of the
ESP8266 board, and the remaining pin of the LED to the GND pin.
Finally, connect the ESP8266 board to your computer via USB.
Controlling Your ESP8266 Remotely

We are now going to connect your ESP8266 board to the aREST cloud server. This is the
complete code for this part:
// Import required libraries

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <aREST.h>
// Clients
WiFiClient espClient;
PubSubClient client(espClient);
// Create aREST instance

aREST rest = aREST(client);
// Unique ID to identify the device for

cloud.arest.io char* device_id = "9u2co4";
// WiFi parameters
const char* ssid = "wifi-name";
const char* password = "wifi-password";
// Functions
void callback(char* topic, byte* payload, unsigned int length);
void setup(void)
{
301
// Start Serial
Serial.begin(115200);
// Set callback
client.setCallback(callback);
// Give name and ID to device
rest.set_id(device_id);
rest.set_name("esp8266");
// Connect to WiFi
WiFi.begin(ssid, password);
delay(500);
Serial.print(".");
}
Serial.println("");
Serial.println("WiFi connected");
void loop() {
// Connect to the cloud

rest.loop(client);
// Handles message arrived on subscribed topic(s)

void callback(char* topic, byte* payload, unsigned int length) {
rest.handle_callback(client, topic, payload, length);
This is a basic aREST sketch for the ESP8266, but you need to modify some parameters. What
you need to change first is the device ID, which identifies the device on the network:
char* device_id = "9u2co4";
Then, modify the WiFi network name and password in the code:
const char* ssid = "wifi-name";

const char* password = "wifi-password";
You can now open the Arduino IDE, and grab the code, and save the sketch somewhere. Make
sure to modify the WiFi name & password inside the sketch. Also give an unique ID to your
board. Then, upload the sketch to the ESP8266 board. Go to your favourite web browser, and
type:
cloud.arest.io/9u2co4/id
302
You should immediately get the answer in JSON format:
{
"id": "9u2co4",
"name": "esp8266",
"connected": true
}
You can now actually completely control your board from the cloud. First, type the following
command to set pin number 5 as an output:
cloud.arest.io/9u2co4/mode/5/o
After that, type the following command to put the LED on:
cloud.arest.io/9u2co4/digital/5/1
Then, you will get the answer in JSON format:
{
"return_value": 1,
"id": "9u2co4",
"name": "esp8266",
"connected": true
}
You can now control your ESP8266 boards from anywhere! As they only cost around $5, it
makes it the perfect solution for your Internet of Things projects.
This is already the end of this guide about how to use the ESP8266 WiFi chip with aREST! I hope
this simple project gave you an idea of what you can do with the ESP8266 along with the aREST
cloud platform, in order to build exciting IoT projects.
If that’s not done yet, you can of course follow my website on Facebook& on Twitter.
Thanks again, and all the best for your IoT projects using aREST!
Marco Schwartz
contact@arest.io
303

Microcontroladores e AppInventor

Enviado por

Direitos autorais:

Formatos disponíveis

Microcontroladores e AppInventor

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

Microcontroladores e AppInventor

Enviado por

Direitos autorais:

Formatos disponíveis

Microcontroladores e Automação Residencial –

Introdução ao Controlado de Elementos via

Autores: Pedro Ventura de Oliveira

Uberlândia, setembro de 2018.

1.1. Justificativa .................................................................................................................. 1

2. Conceitos Básicos de Eletricidade e Eletrônica com analogia Hidráulica ............................ 3

2.1. Condução hidráulica continua ...................................................................................... 3

2.2. Condução elétrica continua.......................................................................................... 5

2.3. Condução hidráulica alternada..................................................................................... 6

2.4. Condução elétrica alternada ........................................................................................ 9

2.5. Fluxo hidráulico em sentido único ................................................................................ 9

2.6. Fluxo de elétrons em sentido único .............................................................................10

2.7. Resistencia hidráulica .................................................................................................11

2.8. Resistencia elétrica .....................................................................................................13

2.9. Usando modelo de acionamento para produzir trabalho .............................................17

2.10. Utilizando relé para acionamento de carga..............................................................17

2.11. Controle de fluxo hidráulico através de registro .......................................................18

2.12. Controle do fluxo de elétrons através de transistor ..................................................20

3.1. Por que utilizar o Arduino? ..........................................................................................23

3.2. Hardware do Arduino Uno...........................................................................................24

3.3. Shields ........................................................................................................................28

3.4. Arduino IDE ................................................................................................................29

INSTALAÇÃO DO IDE (WINDOWS) ..................................................................................29

INSTALAÇÃO DO IDE (LINUX) .........................................................................................33

Instalação do IDE (MAC OSX) ...........................................................................................34

IDE PORTÁTIL (WINDOWS E LINUX) ..............................................................................36

ARDUINO WEB EDITOR ...................................................................................................37

INTERFACE DO IDE .........................................................................................................37

BIBLIOTECAS ATRAVÉS DO IDE .....................................................................................42

BIBLIOTECAS EXTERNAS AO IDE ..................................................................................44

3.6. Estruturas condicionais para programação .................................................................46

3.7. Funções para programação ........................................................................................49

3.8. Variáveis e operadores booleanos, aritméticos e de comparação...............................50

3.9. A programação e erros de conexão ............................................................................51

3.10. Corrigindo problemas de conexão ...........................................................................55

3.11. Criando e executando um sketch ............................................................................59

LEDS ALTERNADOS ........................................................................................................65

SEMAFORO INTELIGENTE ..............................................................................................70

UTILIZANDO O MONITOR SERIAL COM A PROGRAMAÇÃO .........................................72

4. APP INVENTOR: Programação mobile ..............................................................................77

4.1. Por que utilizar o App Inventor? ..................................................................................77

4.2. Acessando ..................................................................................................................78

4.3. Contato inicial .............................................................................................................80

4.4. Novo projeto: duas visões ...........................................................................................81

4.5. Designer .....................................................................................................................84

COMPONENTS E SCREENS ............................................................................................86

4.6. Blocks .........................................................................................................................90

4.7. Elaborando projetos ....................................................................................................92

4.8. MIT AI2 Companion ....................................................................................................96

4.9. Criando um aplicativo .................................................................................................97

“HELLO, WORLD!” AO CLICK DE UM BOTÃO .................................................................98

TRANSFORMAR QUALQUER TEXTO EM FALA ............................................................106

ALTERNAR IMAGENS EM TELAS DIFERENTES CLICANDO NUM BOTÃO .................111

ALTERAR IMAGENS NUMA MESMA TELA CLICANDO NUM BOTÃO ..........................117

5. Integração Arduino e App Inventor ...................................................................................124

5.1. Por que integrar as duas plataformas? .....................................................................124

5.2. Comunicação com realimentação efetiva em tempo real ..........................................125

MODELO CLIENTE-SERVIDOR ......................................................................................125

RESPOSTA EM TEMPO REAL .......................................................................................126

5.3. Comunicação via Bluetooth ......................................................................................127