[1]

Curso: Curso: Introdução ao Arduino com o uso de laboratórios remotos.

Revisão 2. 2021

Este documento e suas imagens estão licenciados sob a licença Creative Commons -
Atribuição-NãoComercial-Sem Derivados 4.0 Internacional. Uma cópia desta licença pode
ser visualizada em http://creativecommons.org.nz/ licences/licences-explained/.
Ela define que este manual é livre para reprodução e distribuição, porém sempre deve ser
citado o autor. Não deve ser usado para fins comerciais ou financeiros e não é permitido
qualquer trabalho derivado.

Laboratório de Experimentação Remota – RExLab

Universidade Federal de Santa Catarina - UFSC
Rua. Pedro João Pereira, 150 - Mato Alto, Araranguá – SC. CEP 88905-120
Contatos: rexlab@contato.ufsc.br; rexlabufsc@gmail.com
Telefone: (48) 3721-4194 ou (48) 3721-4682
[2]
Sumário
Apresentação do curso............................................................................................................... 4
Objetivos ................................................................................................................................. 4
Requisitos ............................................................................................................................... 4
Metodologia ........................................................................................................................... 4
Programa ................................................................................................................................ 4
Certificação ............................................................................................................................. 4
Conhecendo o Arduino .............................................................................................................. 5
O que é Arduino...................................................................................................................... 5
Para que serve o Arduino? ..................................................................................................... 6
O Ambiente para Desenvolvimento em Arduino ....................................................................... 7
O hardware do laboratório remoto ......................................................................................... 11
Introdução a programação do Arduino.................................................................................... 20
Estrutura de sketch do Arduino............................................................................................ 20
Exemplos práticos utilizando o laboratório remoto ................................................................ 23
Praticando com LED .............................................................................................................. 23
Conhecendo um pouco mais os LEDS .............................................................................. 26
Praticando com um LCD ....................................................................................................... 28
Conhecendo um pouco mais o LCD.................................................................................. 31
Sensor de temperatura com o Arduino ................................................................................ 32
Conhecendo um pouco mais os termistores ................................................................... 36
Programa exemplo ........................................................................................................... 38
Praticando com sensor de luminosidade ............................................................................. 39
Conhecendo um pouco mais um LDR .............................................................................. 42
Praticando com um servo motor .......................................................................................... 44
Conhecendo os servos motores ....................................................................................... 47
Referências ............................................................................................................................... 50

[3]
APRESENTAÇÃO DO CURSO
OBJETIVOS
O objetivo deste curso é que os participantes obtenham conhecimentos sobre a plataforma
Arduino e que ao final dele estejam aptos a realizar projetos com placas Arduino ou
compatíveis. Neste curso os participantes também aprenderão os conceitos de hardware e
software livre, microcontroladores, sobre o mundo maker e DIY (Do it Yourself ou faça você
mesmo, em português).
Ao final do curso, os participantes poderão:
• Conhecer a linguagem de programação utilizada no Arduino;
• Programar e executar programas na plataforma Arduino e compatíveis;
• Usar o ambiente de programação remoto de forma eficaz;
• Conhecer o potencial do Arduino para usar em aplicação aplicações de automação e
robótica;
• Aprender a operar componentes de hardware para receber sinais externos usando
sensores;
• Controlar elementos para interagir com o mundo físico através de atuadores;
• E outras.
REQUISITOS
Este curso é para iniciantes, portanto não é necessário conhecimento prévio.
METODOLOGIA
O curso será realizado na modalidade EaD e será composto por uma combinação de teoria e
prática que estabelecem as bases necessárias para entender a plataforma Arduino, em termos
de hardware e software, com duração de 20 horas. As atividades práticas serão realizadas
utilizando laboratórios remotos.
PROGRAMA
• Conhecendo o Arduino
• O Ambiente para Desenvolvimento em Arduino
• O hardware do laboratório remoto
• Introdução a programação do Arduino
• Exemplos práticos utilizando o laboratório remoto
CERTIFICAÇÃO
Estarão aptos para receber os certificados aqueles que realizarem as tarefas e atividades
determinadas no ambiente virtual de ensino e aprendizagem.

[4]
CONHECENDO O ARDUINO
O QUE É ARDUINO

O Arduino é uma plataforma de prototipagem para hardware, baseada em uma placa com
microcontrolador e um ambiente de desenvolvimento, projetado para facilitar o uso de
eletrônicos em projetos multidisciplinares. Foi desenvolvida por Massimo Banzi e David
Cuartielles em 2005 na Itália, com o objetivo facilitar o desenvolvimento de projetos, desde
os mais simples aos mais complexos.
A plataforma Arduino em si é um hardware de código aberto, ou seja, embora exista uma
empresa chamada Arduino que produz placas e dá suporte ao Arduino IDE, existem muitas
outras empresas que produzem placas “Arduino compatível” e que também podem ser
programados no IDE Arduino. Esta característica amplia de forma muito expressiva a
disponibilidade de recursos de software e hardware para apoiar o uso da plataforma. Além
disso, o hardware do Arduino é geralmente de custo baixo, e isso ajuda a sua popularidade.
A plataforma Arduino foi projetada para ser de fácil uso por iniciantes ou por aqueles que não
têm experiência em desenvolvimento de software, eletrônica, sistemas embarcados, etc.
Pode-se conectar a plataforma Arduino ao um computador pessoal através de um simples
cabo USB e programa-la. A linguagem de programação do Arduino foi desenvolvida reduzindo
significativamente a sua complexidade através da criação de funções simples que a tornam
mais simples de usar. Além disso, estão disponíveis muitas bibliotecas de código do Arduino
que podem ser instaladas e usadas. Estas bibliotecas simplificam o uso de todos os tipos de
componentes, desde a maneira de interagir com diferentes tipos de sensores, até controlar
os diferentes de saídas. O código para programação do Arduino tem funções específicas para
ler as entradas e controlar as saídas, tornando mais simples a programação. A conexão com
dos componentes elétricos ao microcontrolador também é muito fácil com uma placa
Arduino, porque ela tem conectores nas bordas da placa para esta finalidade.
Com Arduino é possível construir artefatos que possam responder e/ou controlar, por
exemplo, a luz, o som, o toque ou o movimento, entre outros. O Arduino tem sido usado para
construir uma variedade incrível de coisas, incluindo robôs, jogos, entre outros.
Portanto, o Arduino, é um dispositivo programável como um computador ou um dispositivo
móvel, por exemplo, ou seja, pode-se alterar a sua funcionalidade por meio de comandos em
uma linguagem de programação específica que é capaz de ser interpretada pelo dispositivo e
seguir esses comandos a fim de executar uma tarefa automática ou resolver um problema.
Diferente dos computadores ou dispositivos móveis onde a entrada de dados ocorre através
da interação com teclados, mouses ou a inclinação do smartphone, entre outras, e a saída
ocorre através de um display, no Arduino, as possibilidades de entradas e saídas de dados, são
mais amplas e podem ser utilizados uma grande variedade de componentes de hardware do
tipo sensores e atuadores.
Estes dispositivos (transdutores) podem ser utilizados para converter variações de energia
produzidas por alterações no ambiente físico, em sinais elétricos compreensíveis pelas
máquinas (vide Figura 1). Neste sentido as entradas para este tipo de plataforma (Arduino e
similares) são os sensores e as saídas são os atuadores que convertem os sinais elétricos em
magnitudes físicas.

[5]
Portanto, o Arduino é um dispositivo programável que permite a interação com o ambiente.
Por exemplo, pode-se efetuar a leitura da temperatura e da umidade de um ambiente, entre
as diversas aplicações possíveis.

Figura 1: Sensores e Atuadores

A plataforma Arduino não contempla apenas o hardware (HW), mas também disponibiliza o
software que consiste em um ambiente de desenvolvimento (IDE - Integrated Development
Environment) e uma linguagem de programação simplificada para utilização do HW. Uma das
principais características do software (IDE) e da linguagem de programação é a sua
simplicidade e facilidade de uso. Mais informações podem ser obtidas no site
oficial: https://www.arduino.cc/en/Guide/Introduction.
Então, podemos definir o Arduino a partir de três itens: o hardware físico, que utiliza um
microcontrolador, o ambiente de desenvolvimento Arduino, chamado Arduino IDE, e o código
(programa) que no Arduino é chamado de sketch.
PARA QUE SERVE O ARDUINO?
O Arduino pode ser usado para desenvolver dispositivos artefatos autônomos, conectando-se
a dispositivos e interagindo com hardware e software. Por exemplo, possibilita a construção
de agentes autônomos (aparatos robóticos), controlar luzes, monitorar temperaturas, acionar
motores, etc. Para a aplicação em dispositivos conectados à internet, o Arduino é uma solução
muito boa.
O Arduino é amplamente utilizado em muitos programas educacionais, particularmente por
pessoas que querem criar facilmente protótipos, e que não precisam do conhecimento
aprofundado nem dos detalhes técnicos por trás de suas criações. Projetado pensando nos
usuários o software inclui muitos códigos de exemplo para demonstrar como usar as várias
instalações da placa Arduino.
Embora seja fácil de usar, o hardware do Arduino funciona no mesmo nível de sofisticação dos
utilizados regularmente pelos projetistas que desenvolvem e constroem sistemas embarcados
nas empresas. Em geral, profissionais e entusiastas que tenham trabalhado com
microcontroladores e plataformas embarcadas são atraídos pelo Arduino devido a sua
capacidade ágil de desenvolvimento e as suas facilidades para rápida implementação de
ideias.

[6]
O AMBIENTE PARA DESENVOLVIMENTO EM ARDUINO
Antes de iniciarmos a utilização do hardware do Arduino, vamos conhecer o software Arduino.
O ambiente de desenvolvimento integrado também chamado IDE (acrônimo de Integrated
Development Environment), é um programa de computador composto por um conjunto de
ferramentas de programação. Este pode ser dedicado exclusivamente a uma única linguagem
de programação, ou pode ser usado para vários idiomas. Um IDE é um ambiente de
programação composto por um programa aplicativo, que consiste em um editor de código,
um compilador, um depurador e uma interface gráfica (GUI). No caso do Arduino incorpora as
ferramentas necessárias para carregar um programa já compilado na memória flash do
hardware.
No curso será utilizado, como ambiente de desenvolvimento, o laboratório remoto “Ambiente
para Desenvolvimento em Arduino”. Este ambiente tem como objetivo auxiliar nos estudos e
práticas relacionadas a programação para o microcontrolador Arduino, e permite a
verificação, carregamento de códigos e manipulação de um Arduino remotamente, através da
Internet. Também possibilita o controle de sensores e atuadores destinados a alunos de todos
os níveis educacionais, hobistas e demais interessados nas áreas de eletrônica, programação
de computadores, automação, etc.
O laboratório remoto (LR) está disponível no sistema de gerenciamento RELLE (Remote Labs
Learning Enviromment), que provê uma série de funcionalidades necessárias para a
administração de experimentos remotos. O acesso ao LR poderá ser realizado em
http://relle.ufsc.br/, conforme mostra a Figura 2.

Figura 2: Página de acesso ao laboratório remoto

[7]
Após selecionar a opção “Acessar” será apresenta a tela mostrada na Figura 3.

Figura 3: Acessando o laboratório remoto

Após selecionar a opção “Acessar” o utilizador será direcionado para o ambiente de

desenvolvimento, mostrado na Figura 4, e terá um tempo de 20 minutos para realização de
sua atividade prática. A Figura 4 mostra a organização do experimento Ambiente de
Desenvolvimento para Arduino no RELLE, que é composto pelo ambiente de desenvolvimento
do software [1], da janela para transmissão do streaming de imagens [2] e do diagrama
esquemático do hardware [3].

① ②
②

Figura 4: Acessando o ambiente de desenvolvimento

[8]
O IDE, mostrado na Figura 5, será a ferramenta de trabalho durante o curso, daí a importância
de saber como funciona.
Os programas Arduino são compostos por um único arquivo com uma extensão “ino”, embora
também seja possível organizá-lo em vários arquivos. É recomendado que o arquivo principal
deve estar sempre em uma pasta com o mesmo nome do arquivo.

Figura 5: Ambiente para desenvolvimento do software

As funções dos menus e opções disponíveis são apresentadas a seguir:

1. Menu de bibliotecas e exemplos disponíveis;
2. Nome do arquivo sendo trabalhado;
3. Opção para verificar o código;
4. Execução do código;
5. Abrir um código disponível em disco;
6. Salvar o código em disco;
7. Selecionar o monitor serial;
8. Código em edição/execução.
O monitor serial é uma parte importantes do IDE Arduino. É um pequeno utilitário integrado
dentro do IDE Standard que nos permite enviar e receber facilmente informações através da
porta serial.
A Figura 6 mostra o monitor serial disponível no ambiente de desenvolvimento.

[9]
Figura 7: Ambiente para desenvolvimento do software – monitor serial

[10]
O HARDWARE DO LABORATÓRIO REMOTO
O laboratório remoto está implementado a partir da comunicação serial via cabo USB com a
placa Arduino Uno que recebe dados advindo de um computador embarcado Raspberry Pi. O
circuito da aplicação é composto por um shield onde estão conectados os módulos com
sensores e atuadores.
A Figura 8 apresenta o diagrama de conexões dos recursos de hardware disponíveis no
laboratório remoto.

Figura 8 - Ambiente para Desenvolvimento em Arduino.

Os itens de hardware disponíveis, além da placa Arduino Uno, são os seguintes:

1. Shield. Um shield é uma placa de circuito modular que é montada em cima de outra
para dar funcionalidade extra ao Arduino.
2. Servo motor;
3. Módulo display LCD 16x2;
4. Módulo LED;
5. Módulo sensor de luminosidade;
6. Módulo sensor de temperatura.

O Quadro 1 apresenta com mais detalhes os dispositivos de hardware instalados no

laboratório remoto para desenvolvimento do Arduino.

[11]
 Quadro 1 – Componentes disponíveis para uso no laboratório remotos

Módulo com LED (diodo emissor de luz), que dispõe de

um potenciômetro para ajustar a potência do LED. O LED
é um atuador usado para a emissão de luz, muito
conveniente para utilização em diversas aplicações.

Módulo sensor de temperatura. Este módulo utiliza um

termistor para detectar a temperatura ambiente. A
resistência do termistor aumentará quando a
temperatura ambiente diminuir. Essa característica será
usada para calcular a temperatura ambiente. A faixa
detectável deste sensor é de -40 - 125ºC, e a precisão é
de ±1,5ºC

O “servo” é um motor DC com engrenagens e sistema de

retroalimentação. É usado, por exemplo, no mecanismo
de condução de robôs.

O módulo LCD 16 x 2 LCD é um display com alto contraste

e fácil implantação. 16x2 significa duas linhas e cada linha
tem 16 colunas, 32 caracteres no total.

O módulo sensor de luz incorpora um Resistor

Dependente de Luz (LDR). Normalmente, a resistência do
LDR ou Foto resistor diminuirá quando a intensidade da
luz ambiente aumentar. Isso significa que o sinal de saída
deste módulo será ALTO em luz brilhante, e BAIXO no
escuro.

Arduino Uno. O micro controlador Arduino Uno é uma

placa onde o usuário pode conectar componentes tais
como os usados neste experimento e realizar a
programação para que execute as funções desejadas pelo
mesmo.

A placa Arduino Uno e os sensores e atuadores estão conectados a um shield que dispõe de
16 portas, divididas em quatro áreas funcionais: 4 portas analógicas, 7 portas digitais, 4 portas
I2C (Inter-Integrated Circuit) e 1 porta UART (Universal Asynchrounous Receiver/Transmiter ou
Receptor/Transmissor Universal Assíncrono).

[12]
A Figura 9 mostra a distribuição das portas no shield. No shield, Figura 9, são apresentados os
números dos conectores em letras maiores, por exemplo: D4, D3, I2C, A2, etc. Já as letras
menores indicam os pinos de conexão na placa do Arduino. Por exemplo, o conector D4 do
shield, está relacionado aos pinos digitais D5 e D4 do Arduino, representados pelas cores
branco (D5) e amarelo (D4) dos cabos de conexão dos módulos de sensores e atuadores.
Todos os módulos tem cores que identificam o tipo de sinal, por exemplo, o fio amarelo
transmite o sinal (“SIG”), o fio preto transmite o GND e o fio vermelho transmite o VCC (5
Volts). Já o fio branco não transmite nenhum sinal, e está marcado com “NC”.

Figura 9: Distribuição das portas no shield

Conforme mostra a Figura 9 estão sete portas digitais, rotuladas de D2 a D8. Cada uma delas
lida com um par de pinos digitais (2/3 ... 8/9) na placa Arduino Uno. Elas podem ser usadas
para ler um sensor digital (por exemplo, um botão) ou controlar um atuador digital (ou
analógico, via PWM). De qualquer forma, cada porta só pode lidar com dois estados lógicos: 0
ou 1.
As portas analógicas, disponíveis em número de quatro possibilitam fazer leituras analógicas
e retornar leituras que variam de 0 a 1023. Em comparação com sensores digitais que só
retornam 0 ou 1, as leituras analógicas são mais detalhadas e precisas.
Estão disponíveis quatro portas I2C. O I2C é um protocolo de barramento de baixa velocidade
que transfere dados através de dois fios: SCL e SDA. O SCL é a linha de relógio para sincronizar
a transferência de dados sobre o barramento I2C; SDA é a linha de dados.
Um sensor é um dispositivo capaz de detectar magnitudes físicas ou químicas, chamadas
variáveis de instrumentação, e transformá-las em variáveis elétricas. As variáveis de
instrumentação podem ser, por exemplo: temperatura, intensidade da luz, distância,
aceleração, inclinação, deslocamento, pressão, força, torção, umidade, movimento, pH, etc.
Já uma magnitude elétrica pode ser uma resistência elétrica, uma capacidade elétrica (por
exemplo a partir de um sensor de umidade ou um sensor capacitivo), uma tensão elétrica (por
exemplo em um termopar), ou uma corrente elétrica (como em um foto transistor), etc. Os
sensores podem ser classificados com base nos dados de saída em digitais ou analógicos.
Durante o curso será utilizada a placa Arduino UNO, que é dos modelos mais conhecidos e
documentado. Lançado em 2010, ele vem equipado com microcontrolador Atmega328p com
32Kbytes de ROM para armazenar o programa. As especificações técnicas da placa Arduino
Uno são as seguintes:

[13]
 • Microcontrolador: ATmega328
• Portas Digitais: 14
• Portas Analógicas: 6
• Memória Flash: 32KB (0,5KB usado no bootloader);
• SRAM: 2KB
• EEPROM: 1KB
• Velocidade do Clock: 16MHz
Maiores informações podem ser obtidas nos links indicados a seguir:
• Placa Arduino Uno: https://www.arduino.cc/en/Main/ArduinoBoardUno
• Diagrama esquemático: http://arduino.cc/en/uploads/Main/Arduino_Uno_Rev3-
schematic.pdf
• Microcontrolador: http://www.atmel.com/devices/atmega328p.aspx
O Arduino é um computador como qualquer outro, porém em menor escala, ou seja, dispõe
de menor capacidade de memória e também apresenta menor poder de processamento. Suas
principais partes são:
• Microprocessador. Que é responsável pela execução das funções lógicas, aritméticas,
etc.;
• Memória RAM. Memória volátil utilizada para armazenar dados e instruções;
• Memória FLASH. Memória não volátil utilizada para armazenar o software;
• Demais componentes necessários a um sistema computadorizado, tais como,
temporizadores (timers), contadores, gerador de clock, etc.
Detalhando um pouco mais os três tipos de memórias utilizadas no Arduino:
• SRAM (Static Random Access Memory): É uma memória volátil utilizada para
variáveis locais e dados parciais. É a área de memória onde o sketch cria e manipula
variáveis quando é executado. É um recurso limitado e devemos monitorar seu uso
para evitar esgotá-lo. Sua capacidade no Arduino Uno é de 2KB.
• EEPROM (Electrically Erasable Programmable Read-Only Memory): Memória não
volátil para armazenamento dos dados após uma reinicialização. Pode ser gravada a
partir do programa de microcontrolador, geralmente também abriga as constantes
do programa. As EEPROMs têm um número limitado de leituras/gravações. Este
tipo de memória só permite a leitura byte a byte e seu uso pode ser um pouco
complicado. Também é um pouco mais lenta que a SRAM. A vida útil de uma
EEPROM é de cerca de 100.000 ciclos de gravação. Sua capacidade no Arduino Uno
é de 1KB.
• Flash: É uma memória não volátil onde ficar armazenado o programa. Sua capacidade
no Arduino Uno é de 32KB. É nela que o sketch já compilado é salvo. Seria o
equivalente ao disco rígido de um computador. Na memória flash também é
armazenado o bootloader (programa inicializador). É possível executar um programa
a partir da memória flash, mas não é possível modificar os dados, neste caso é

[14]
 necessário copiar os dados na SRAM para poder modificá-los. A memória flash usa a
mesma tecnologia dos cartões SD, pen drives ou alguns tipos de SSD, esta memória
tem uma vida útil de cerca de 100.000 ciclos de gravação.
A Figura 11 apresenta a placa Arduino Uno e os principais componentes que a compõem.

Figura 11 – Placa Arduino Uno.

A seguir é apresentada a descrição dos itens apontados na Figura 11:

1. Botão de reset;
2. Porta USB;
3. Conector de alimentação. O circuito interno do Arduino é alimentado com uma
tensão contínua de 5V, por exemplo, quando é conectado a uma porta USB de um
computador. Esta conexão fornece a alimentação e também a comunicação de
dados;
4. Pinos de alimentação para sensores;
5. Pinos para sinais analógicos;
6. Microcontrolador programável;
7. Conexão ICSP. Permite que o Arduino possa programar diretamente os
microcontroladores da placa usando o protocolo serial SPI;
8. Pinos para sinais digitais.
A Figura 12 mostra o botão de reset, este botão tem como única função reinicializar o Arduino
Uno.

[15]
 Figura 12: Botão de reset

A Figura 13 mostra a porta USB. Esta é a porta usada para estabelecer uma conexão entre a
placa de Arduino e um microcomputador. É ela que permite o envio de códigos para o
processador, permite conexão com a serial e também é usada para a alimentação da placa.

Figura 13: Porta USB

A Figura 14 apresenta o conector de Alimentação externa. Este conector é utilizado quando

não estiver sendo usada a porta USB para conexão com o computador. Neste caso sendo
usado para alimentar a placa. Este conectar permite alimentar a placa com tensões entre 6 e
12 volts.

Figura 14: Conector de alimentação externa

A Figura 15 mostra os conectores de alimentação para conexão de shields e outros módulos

na placa Arduino UNO.

Figura 15 – Conectores de alimentação Arduino UNO R3

[16]
A função de cada conector é descrita a seguir:
• IOREF: Fornece uma tensão de referência para que shields possam selecionar o tipo
de interface apropriada, dessa forma shields que funcionam com a placas Arduino
que são alimentadas com 3,3V. podem se adaptar para ser utilizados em 5V. e vice-
versa.
• RESET: pino conectado a pino de RESET do microcontrolador. Pode ser utilizado para
um reset externo da placa Arduino.
• 3,3 V: Fornece tensão de 3,3V. para alimentação de shield e módulos externos.
Corrente máxima de 50 mA.
• 5 V: Fornece tensão de 5 V para alimentação de shields e circuitos externos.
• GND: pinos de referência, terra.
• VIN: pino para alimentar a placa através de shield ou bateria externa. Quando a placa
é alimentada através do conector de entrada de alimentação a tensão da fonte
estará nesse pino.
A placa Arduino UNO possui pinos de entrada e saídas digitais são 14 pinos que podem ser
usados como entrada ou saída digitais. Estes Pinos operam em 5 V, onde cada pino pode
fornecer ou receber uma corrente máxima de 40 mA. Cada pino possui resistor de pull-up
interno que pode ser habilitado por software. A Figura 16 mostra os pinos digitais.

Figura 16: Entradas e saídas digitais

Alguns pinos referentes as entradas e saídas digitais possuem funções especiais, são eles:
• PWM: 3,5,6,9,10 e 11 podem ser usados como saídas PWM de 8 bits através da
função analogWrite().
• Comunicação serial: 0 e 1 podem ser utilizados para comunicação serial. Deve-se
observar que estes pinos são ligados ao microcontrolador responsável pela
comunicação USB com o PC.
• Interrupção externa: 2 e 3. Estes pinos podem ser configurados para gera uma
interrupção externa, através da função attachInterrupt().

Um sinal elétrico analógico é aquele no qual os valores da tensão (voltagem) variam

constantemente e podem alcançar qualquer valor. No caso da corrente alternada, o sinal
analógico aumenta seu valor com sinal elétrico positivo (+) por meio ciclo e, em seguida,
diminui com sinal elétrico negativo (–) no próximo meio ciclo.

[17]
Um sistema de controle microcontrolado não tem capacidade de trabalhar com sinais
analógicos, então torna-se necessário converter os sinais analógicos em sinais digitais para
poder trabalhar com eles.
O sinal digital obtido a partir de um analógico tem duas propriedades fundamentais:
• Valores. Qual valor em volts define 0 e 1;
• Resolução analógica: nº de bits usados para representar um sinal analógico com
uma notação digital.
https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-
family/analogreadresolution/ ;
https://www.arduino.cc/reference/pt/language/functions/zero-due-mkr-
family/analogwriteresolution/
Por exemplo no caso de um Arduino Uno, o valor de 0 volts analógicos é expresso em digital
como B0000000000 (0) e o valor de 5V analógico é expresso em digital como B1111111111
(1023). Portanto, cada valor analógico intermediário é expresso com um valor entre 0 e 1023,
ou seja, somamos 1 em binário cada 4,883 mV. O Arduino Uno contém um conversor
analógico-digital de 6 canais na placa. O conversor tem uma resolução de 10 bits, retornando
inteiros entre 0 e 1023. Os pinos analógicos do Arduino também possuem todas as
funcionalidades dos pinos digitais. Portanto, se precisarmos de mais pinos digitais podemos
usar os pinos analógicos. A nomenclatura para pinos analógicos é A0, A1, etc...
No Arduino os pinos analógicos são definidos e têm as seguintes
propriedades: http://arduino.cc/en/Tutorial/AnalogInputPins.
Para tratar as entradas e saídas digitais são utilizadas as seguintes funções:
• analogReference() – configura a referência de tensão usada para entrada
analógica. https://www.arduino.cc/reference/pt/language/functions/analog-
io/analogreference/
• analogRead() – lê o valor do pino analógico especificado.
https://www.arduino.cc/reference/pt/language/functions/analog-io/analogread/
• analogWrite() – escreve um valor analógico (onda PWM) para o pino especificado.
Nem em todos os pinos digitais podem ser aplicados PWM.
https://www.arduino.cc/reference/pt/language/functions/analog-io/analogwrite/

Na Figura 17 são mostrados os seis pinos analógicos disponíveis na placa Arduino Uno.

Figura 17: Entradas e saídas analógicas

[18]
A placa Arduino Uno é equipada com um microcontrolador ATMega328P, vide Figura 17B, que
dispõe de 32 KB de memória tipo Flash, ainda possui 2KB de SRAM e 1KB de EEPROM.

Figura 17B: Microcontrolador

O Quadro 2 as especificações técnicas do microcontrolador ATmega328P.

Quadro 2: especificações técnicas do microcontrolador ATmega328P

Tensão de operação 5V
Tensão de entrada
7-12V
(recomendada)
Tensão de entrada (limite) 6-20V
Pinos digitais de I/O 14 (das quais 6 fornecem saída de PWM)
Pinos de I/O Digital PWM 6
Pinos de entrada analógicos 6
Corrente de DC por pino de I/O 20 mA
Corrente de DC para pino de 3.3V 50 mA
32 KB (ATmega328P) dos quais 0,5 KB utilizados pelo
Memória Flash
bootloader
SRAM 2 KB (ATmega328P)
EEPROM 1 KB (ATmega328P)
Velocidade do clock 16 MHz

[19]
INTRODUÇÃO A PROGRAMAÇÃO DO ARDUINO
Uma linguagem de programação é uma linguagem formal projetada para executar processos
que podem ser realizados por máquinas tais como os computadores. Elas podem ser usadas
para criar programas que podem ser utilizados, por exemplo, para controlar o comportamento
físico e lógico de uma máquina, para expressar algoritmos ou como um modo de comunicação.
Uma linguagem de programação consiste em um conjunto de símbolos, regras sintáticas e
semânticas que definem sua estrutura e o significado de seus elementos e expressões. O
processo pelo qual o código de um programa de computador é escrito, testado, depurado,
compilado ou interpretado e mantido é chamado de programação.
A linguagem de programação de Arduino é uma adaptação do C++ que tem origem na avr-libc
que fornece uma biblioteca C para uso com o compilador GCC (C e C++) nos
microcontroladores AVR da Atmel. As ferramentas necessárias para programar os
microcontroladores AVR da Atmel são avr-binutils, avr-gcc e avr-libc e já estão incluídas no IDE
Arduino, mas quando compilamos e carregamos um sketch 1 estamos usando essas
ferramentas. Assim, a programação do Arduino é feita em C ++, porém, o Arduino oferece
algumas bibliotecas que facilitam a programação dos pinos de entrada e saída e das portas de
comunicação, bem como outras bibliotecas para operações específicas. O IDE em si já inclui
essas bibliotecas automaticamente e não é necessário declará-las expressamente.

ESTRUTURA DE SKETCH DO ARDUINO

Um programa Arduino é chamado de sketch ou projeto e tem a extensão “.ino”. Não é
necessário que um sketch esteja em um único arquivo, mas é essencial que todos os arquivos
estejam dentro do mesmo diretório do arquivo principal. Não é necessário que o arquivo
principal (aquele com o mesmo nome do diretório que o contém) deva ter as funções setup()
e loop(). A seguir é apresentada a estrutura básica de um sketch de Arduino:
void setup() {
// inserir aqui o código de configuração aqui, para executar uma vez:

void loop() {
// inserir aqui o código principal, para executar repetidamente:

A estrutura básica de um sketch de Arduino é bastante simples e consiste em pelo menos duas
partes. Estas duas partes são obrigatórias e incluem blocos contendo declarações,
propriedades ou instruções, são elas as funções setup() e Loop().
A função setup() é chamada quando um sketch inicia. É usada para inicializar variáveis,
configurar o modo dos pinos (INPUT ou OUTPUT), inicializar bibliotecas, etc. A função setup()

1
Um projeto do Arduíno é chamado de sketch, e consiste tipicamente em duas partes (rotinas): a rotina de
setup, que inicializa o sketch, e a rotina de loop, que normalmente contém o código principal do programa (é
como a função main() da linguagem C).

[20]
será executada apenas uma vez, após a placa ser alimentada ou acontecer um reset.
[ https://www.arduino.cc/reference/pt/language/structure/sketch/setup/]
Depois de criar uma função setup(), a qual inicializa e atribui os valores iniciais, a função
loop() faz precisamente o que o seu nome sugere, e repete-se consecutivamente enquanto a
placa estiver ligada, permitindo o seu programa mudar e responder a essas mudanças. É usada
para controlar ativamente uma placa Arduino.
[ https://www.arduino.cc/reference/pt/language/structure/sketch/loop/ ]
Além disso, também é possível incluir uma introdução com os comentários que descrevem o
programa e a declaração de variáveis e chamadas para bibliotecas. A Figura 18 mostra o
exemplo de sketch para Arduino

Figura 18 – Exemplo de sketch para Arduino

Os principais componentes de um sketch de Arduino são:

• Variáveis são espaços na memória onde os dados são armazenados, esses dados
podem variar.
• Funções são uma parte do código que pode ser usado/chamado de qualquer lugar do
sketch. Uma função pode ser chamada diretamente ou através da passagem de
parâmetros, dependendo de como ela foi definida.
• setup() e loop(), são duas funções especiais que são obrigatórias para declarar em
qualquer sketch.
• Comentários, servem para documentar o projeto
No fluxograma mostrado na Figura 19 pode ser visualizado um sketch resumido.

[21]
Figura 19 – Fluxograma de sketch para Arduino

[22]
EXEMPLOS PRÁTICOS UTILIZANDO O LABORATÓRIO REMOTO
PRATICANDO COM LED
LEDs (Light-Emitting Diode) podem ser encontrados em muitas cores e tamanhos. Este
exemplo mostra como fazer com um Arduino para ver uma saída física, piscando um LED.
Neste exemplo também se estará mostrando como usar as funções pinMode(),
digitalWrite() e delay().

Figura 20: Alguns tipos de LEDS

Neste exemplo será utilizado o módulo LED, mostrado na Figura 21, e a placa Arduino Uno.

Figura 21: Módulo LED

Conforme mostrado no módulo LED há um resistor variável de 10k ohm que é usado para
controlar o brilho do LED. O módulo LED está conectado no laboratório remoto ao shield
através de um cabo de 4 pinos ao conector D2, conforme mostrado na Figura 22.

Figura 22: Conexão do módulo LED no shield

[23]
A Figura 23 mostra com mais detalhes o diagrama do circuito.

Figura 23: Diagrama do circuito conectando o módulo LED ao Arduino

O módulo LED Grove tem 4 pinos denominados: GND, VCC, NC e SIG onde:
• GND está conectado ao GND do shield e, portanto, ao GND do Arduino;
• O pino VCC é conectado ao VCC do shield e, portanto, ao pino de +5V do Arduino;
• O NC (não conectado) não está conectado;
• O pino SIG (sinal) está conectado ao pino D2 do shield e, portanto, ao pino digital
A02 do Arduino.

Exemplo de código para piscar o LED no circuito apresentado.

/***********************************************************************
**
* Exemplo de pisca-pisca com led para Arduino Uno utilizando o módulo
* conectado ao pino A02.
*
*
************************************************************************
/
#define LED 2 // definir pino onde o LED esta conectado

void setup(void) {
pinMode(LED, OUTPUT); // Inicialize o pino digital como uma saída com
pinMode() para configurar o pino LED como saída.
}
// main loop
void loop() {
digitalWrite(LED, HIGH); // liga o led (HIGH é o nível de tensão)
delay(500); // espera 500ms
digitalWrite(LED, LOW); // Desliga o LED (LOW é o nível de tensão)
delay(500); // espera 500ms
}

// final do código.
Observação: Na função delay( ), 1s equivale a 1000ms.

[24]
A Figura 24 mostra o programa em funcionamento no laboratório remoto “Ambiente de
Desenvolvimento para Arduino.

Figura 24: Programa em uso no laboratório remoto

[25]
Conhecendo um pouco mais os LEDS
Um LED sendo um diodo tem uma queda de tensão que depende do tipo e cor do LED. Para
usar um LED é essencial colocar uma resistência adequada para cada tipo de LED. De acordo
com a lei de ohm: V = I * R, então se a tensão for 5 V e quisermos que o LED trabalhe com
correntes entre 5 mA (0,005 A) e 20 mA (0,02 A), então será necessário utilizar resistores
limitadores de corrente entre 250 e 1000 ohms.
Os LEDs comuns têm dois pinos, vide Figura 25. A extremidade positiva de um LED (pino maior)
é chamada de ânodo, e a extremidade negativa é chamada de cátodo.

Figura 25: Terminais e o símbolo do LED

Para calcular o resistor adequado para um LED é necessário saber:

• Tensão da fonte de alimentação, ou seja, quantos volts serão usados para
alimentar o LED, (5 volts no caso de Arduino);
• Tensão suportada pelo LED em volts. É a tensão necessária para o funcionamento
do LED, geralmente fica entre 1,7 e 3,3 volts, depende da cor do diodo e da
composição dos metais;
• A corrente suportada pelo LED em amperes.
A faixa de atuação dos LEDs, é determinada pelos fabricantes, geralmente a corrente está na
faixa de miliamperes. Quanto maior corrente maior a luminosidade. Para Arduino o valor
máximo será de 20 mA.
O Quadro 3 apresenta alguns valores de referência de acordo com a coloração do LED.
Quadro 3: Características do LEDS
Cor do LED Tensão de limiar [V]
Vermelho 1,6
Vermelho de alta luminosidade 1,9
Amarelo 1,7 a 2
Verde 2,4
Laranja 2,4
Branco brilhante 3,4
Azul 3,4
Azul 430nm 4,6

[26]
A fórmula para calcular o resistor adequado para um LED é:
R = (Valimentação - VLED) / I
Onde:
• R é a resistência em ohms do resistor adequado para o LED;
• Valimentação é a tensão em volts da fonte de alimentação que será usada no LED.
• Vled é a tensão em volts do LED.
• I é a corrente do LED em amperes.

[27]
PRATICANDO COM UM LCD
Neste exemplo estaremos utilizando o LCD 16 x 2, mostrado na Figura 26. O LCD (em inglês
Liquid Crystal Display) é um display LCD I2C de fácil utilização e muito aplicado nas plataformas
Arduino e Raspberry Pi. O termo 16x2 significa que ele dispõe de duas linhas e que cada linha
tem 16 colunas, totalizando 32 caracteres no total.

Figura 26: Módulo Display LCD

A Figura 27 mostra a conexão entre o módulo display LCD e o shield.

Figura 27: Módulo Display LCD

Observa-se na Figura 27 que o display LCD 16×2 está conectado à porta I2C do shield onde:
• O pino GND está conectado ao Arduino GND,
• Pino VCC é conectado ao pino Arduino +5V,
• O SDA está conectado ao pino analógico Arduino 4 (A4),
• O SCL está conectado ao pino analógico Arduino 5 (A5).
O protocolo I2C (Inter-Integrated Circuit) foi desenvolvido pela Philips Semiconductors com o
objetivo de construir um barramento bidirecional usando apenas duas linhas de comunicação.
É um protocolo para curtas distancias, tipicamente dentro de uma mesma placa de circuito
impresso, média velocidade, e necessita de apenas dois fios para comunicação (SDA – dados,
e SCL (clock).
A seguir é apresentado um exemplo de código para utilização do LCD 16x2 no laboratório
remoto.

[28]
 #include <Wire.h>
#include "rgb_lcd.h"
rgb_lcd lcd;
/*
const int colorR = 255;
const int colorG = 0;
const int colorB = 0;
*/

void setup() {
// configurar o número de colunas e linhas do LCD:
lcd.begin(16, 2);
lcd.setRGB(colorR, colorG, colorB);

lcd.print("Alo, Mundo!"); // Imprimir uma mensagem para o LCD.

delay(1000);
}

void loop() {
// (nota: a linha 1 é a segunda linha, já que a contagem começa com 0):
lcd.setCursor(0, 1); // definir o cursor para a coluna 0, linha 1
lcd.print(millis()/1000); // imprimir o número de segundos desde o reset:
delay(100);
}

Comentando o código
#include <Wire.h> // Inclui biblioteca Arduino Wire
#include "rgb_lcd.h" // inclui biblioteca LCD
A diretiva #include é usada para incluir bibliotecas externas ao seu /sketch.
Isso dá acesso a um grande número de bibliotecas padrão da linguagem //C
(grupos de funções prontas), e também bibliotecas escritas especialmente
para a linguagem Arduino.
Note que #include, similarmente a #define, não é terminada com um ponto e
vírgula, e o compilador irá mostrar mensagens de erro enigmáticas se você
adicionar um.

rgb_lcd lcd; // Inicializa a biblioteca LCD

//cria um objeto do tipo lcd para controlar o display

const int colorR = 255;

const int colorG = 0;
const int colorB = 0;
//

void setup() {
//A palavra-chave void é usada apenas em declarações de funções. Ela indica
que é esperado que a função não retorne nenhuma informação para a função da
qual foi chamada.
lcd.begin(16, 2);

[29]
// inicializa o LCD com 16 colunas e 2 linhas.

lcd.setRGB(colorR, colorG, colorB);

lcd.print("Alo, Mundo!");
// Imprimir uma mensagem para o LCD.

delay(1000);
//delay(ms) Pausa o programa por uma quantidade especificada de tempo (em
milissegundos). Cada segundo equivale a 1000 milissegundos.

void loop() {
lcd.setCursor(0, 1); // definir o cursor para a coluna 0, linha 1. (nota: a
linha 1 é a segunda linha, já que a contagem começa com 0):
lcd.print(millis()/1000); // imprimir o número de segundos desde o reset. //

delay(100);
}

// Final do código de exemplo.

[30]
Conhecendo um pouco mais o LCD
O LCD (Display de Cristal Líquido) é um dispositivo gráfico amplamente utilizado nos mais
diversos tipos de projetos. O LCD é formado por uma fina camada de cristal líquido entre duas
placas de vidro, com uma fonte de luz fluorescente ou de LEDs por baixo de toda essa
estrutura. A formação de caracteres e imagens ocorre devido ao fato do cristal líquido,
naturalmente transparente, se tornar opaco ao receber uma carga elétrica, impedindo a
passagem de luz.
Existem, basicamente, dois tipos de LCDs:
• Caractere: Esses tipos de LCD permitem apenas a escrita de caracteres, números e
pequenos símbolos criados pelo usuário. Alguns tamanhos comuns para esse tipo de
display são: 8×2, 16×2, 20×4, 24×4, 40×2, entre outros.
• Gráficos: Os LCDs gráficos possuem resoluções bem maiores e permitem a exibição de
figuras e imagens. Alguns tamanhos comuns para esse tipo de display são: 122×32,
128×64, 240×64, 240×128, entre outros.
No módulo LCD é utilizado um LCD 16×2. Isso quer dizer que esse display pode apresentar
16×2, ou seja, 32 caracteres em sua tela. Na Figura 28 é possível identificar a disposição dos
caracteres na tela.

Figura 28: Display LCD 16x2

Cada caractere é composto de uma matriz de 5 colunas por 8 linhas de pixels. O estado desses
pixels, “ligados” ou “desligados”, desenharam o caractere. A Figura 29 mostra como estão
dispostos os pixels para formar um caractere. No caso com todos os pixels ligados, com todos
os pixels desligados e configurados para formar a letra “V”.

Figura 29: Formação de caracteres no LCD

[31]
SENSOR DE TEMPERATURA COM O ARDUINO
O módulo sensor de temperatura utiliza um termistor para detectar a temperatura ambiente.
Um termistor é um elemento sensor de temperatura composto por material semicondutor
sinterizado, capaz de exibir uma grande alteração de resistência proporcional a pequenas
alterações de temperatura. Os termistores geralmente apresentam coeficiente de
temperatura negativo, o que significa que a resistência do termistor diminui à medida que a
temperatura aumenta. No módulo utilizado a resistência de do termistor aumentará quando
a temperatura ambiente diminuir. É essa característica que se usa para calcular a temperatura
ambiente.
A Figura 30 mostra o módulo sensor de temperatura utilizado no laboratório remoto.

Figura 30: Módulo sensor de temperatura

O módulo sensor de temperatura contém um termistor, modelo NCP18WF104F03RC, que é

um resistor variável, cujo valor da resistência depende da temperatura ambiente. O módulo
usa um termistor NTC (Negative Temperature Coefficient), o termo "coeficiente de
temperatura negativo" significa que quando a temperatura do componente aumenta, sua
resistência diminui, e vice-versa.
A faixa detectável do sensor utilizado no módulo sensor de temperatura é de -40 - 125ºC, e a
precisão é de ±1,5ºC. As especificações do sensor são as seguintes:
• Tensão: 3.3 ~ 5V
• Resistência de potência zero: 100 KΩ
• Tolerância à resistência: ±1%
• Faixa de temperatura de operação: -40 ~ +125 °C
• B-Constante nominal: 4250 ~ 4299K
Em relação as conexões do modulo, vide Figura xx, são assim identificadas:
• Vermelho = 5V
• Preto = Ground
• Branco = não conectado
• Amarelo = Pino de saída do Arduino (A1)

[32]
O módulo de temperatura está conectado a uma das portas analógicas disponíveis, no caso
A1. A Figura 31 mostra a conexão do módulo sensor de temperatura ao shield.

Figura 31: Conexão do módulo sensor de temperatura ao shield

No sketch de exemplo vamos ler o estado do sensor de temperatura e calcular a temperatura

em graus Celsius.

/* Módulo sensor de temperatura

*
Este sketch lê a tensão do sensor de temperatura do módulo e
calcula a temperatura em graus C.
Módulo sensor de temperatura conectado a entrada A1.
*/

#include <math.h>
// A biblioteca de math foi incluída porque precisamos fazer alguns cálculos, um dos
quais é um logaritmo.

const int B = 4275; // B valor do termistor.

/*O coeficiente B depende do módulo do termistor e pode ser encontrado nas
especificações fornecidas pelo fabricante.*/

const int R0 = 10000; // R0 = 10k

// Definimos o resistor divisor de tensão de correção. O módulo de temperatura contém
um //resistor de 10KΩ.
// Estes valores são necessários para o cálculo da temperatura no loop.

const int pinTempSensor = A1;

// Modulo sensor de temperatura conectado ao pino analógico 1 (A1) do
//Arduino.

void setup()
{
Serial.begin(9600);
}

[33]
 void loop()
{
int a = analogRead(pinTempSensor);
float R = 1023.0/a-1.0;
R = R0*R;
float temperatura = 1.0/(log(R/R0)/B+1/298.15)-273.15;
/* converte para temperatura de acordo com os dados do fabricante do
termistor.
Dentro do loop, a temperatura é calculada em graus Celsius quebrando a
fórmula em três partes, e elaborando alguns resultados intermediários.*/

Serial.print("temperatura = ");
Serial.println(temperatura);

delay(100);
}

A Figura 32 mostra o programa em funcionamento no laboratório remoto “Ambiente de

Desenvolvimento para Arduino.

Figura 32: Programa em uso no laboratório remoto

O passo seguinte é abrir o Monitor Serial do Arduino IDE conforme mostra a Figura 33.

[34]
 Figura 33: Selecionando o monitor de comunicação serial

Se o código estiver funcionando adequadamente serão mostradas as leituras do sensor

conforme mostra a Figura 34.

Figura 34: Leitura do terminal de comunicação serial

[35]
Conhecendo um pouco mais os termistores
Um termistor é um sensor que serve para detectar temperatura através de alterações na
resistência de acordo com o calor ou frio detectado. Um termistor é composto de um
semicondutor como óxido férrico, óxido de níquel ou óxido de cobalto. À medida que a
temperatura aumenta, a concentração dos portadores varia, de modo que a resistência do
dispositivo varia. Existem dois tipos de sensores de acordo com seu coeficiente de
temperatura o NTC (Negative Temperature Coefficient ou coeficiente de temperatura
negativo) e PTC (Positive Temperature Coefficient ou coeficiente de temperatura positivo).
Num NTC, quando a temperatura aumenta, a resistência diminui.
Por outro lado, quando a temperatura diminui, a resistência aumenta, este tipo de este tipo
de termistor é o mais usado. Um termistor PTC funciona um pouco diferente. Quando a
temperatura aumenta, a resistência aumenta, e quando a temperatura diminui, a resistência
diminui. Este tipo de este tipo de termistor é geralmente usado como um fusível. Os símbolos
do termistor são mostrados na Figura 35:

Figura 35: Símbolos de representação dos termistores

A seta apontada pelo T significa que a resistência é variável com base na temperatura. A
direção da seta ou da barra não é significativa. Os termistores são fáceis de usar, baratos,
resistentes e respondem previsivelmente às mudanças de temperatura. Embora não
funcionem bem com temperaturas excessivamente quentes ou frias, eles são os sensores
escolhidos para aplicações que medem a temperatura em um ponto base desejado. São ideais
quando são necessárias temperaturas muito precisas.
Alguns dos usos mais comuns dos termômetros estão em termômetros digitais, em carros
para medir temperaturas de óleo e refrigeração, e em eletrodomésticos, como fornos e
geladeiras, mas também são encontrados em quase qualquer aplicação que exija circuitos de
proteção de aquecimento ou resfriamento para operação segura. Para aplicações mais
sofisticadas, como detectores de estabilização a laser, blocos ópticos e dispositivos acoplados
de carga, os termistores são incorporados.
Um termistor não “lê” nada, em vez disso, a resistência de um termistor muda de acordo com
a temperatura. Ao contrário de outros sensores, os termistores não são lineares, o que
significa que os pontos em um gráfico representando a relação entre resistência e
temperatura não formarão uma linha reta. A localização da linha e o quanto ela muda é
determinada pela construção do termistor.
Um gráfico típico do termistor se parece com o mostrado na Figura 36.

[36]
Figura 36: Gráfico de resposta resistência vs temperatura

[37]
Programa exemplo
/*Função: Comunicação serial (leitura e escrita), LED vermelho e visor LCD
16x2.LED: pino 2. LCD RGB. Porta serial: baudrate 9600*/

#include <Wire.h>
#include "rgb_lcd.h" // Biblioteca do visor LCD
String state;
rgb_lcd lcd;

/* Cores do visor LCD */

const int colorR = 0;
const int colorG = 0;
const int colorB = 255;

/* Parâmetros do sensor de temperatura */

int a;
float temperatura;
int B = 3975; //B valor do termistor
float resistencia;

void setup() { // Função setup de execução unica

lcd.begin(16, 2); // Número total de Colunas e Linhas
lcd.setRGB(colorR, colorG, colorB); //Aplica as cores ao visor

lcd.setCursor(2, 0); // Cursor na posição (coluna, linha)

lcd.print("RExLab - UFSC"); // Escreve esta string no LCD
lcd.setCursor(4, 1); // Cursor na posição (coluna, linha)
lcd.print("GT - MRE"); // Escreve esta string no LCD
delay(5000); // Tempo de espera
lcd.clear(); // Limpa o display LCD

lcd.setCursor(2, 0); // Cursor na posição (coluna, linha)

lcd.print("Display LCD"); // Escreve esta string no LCD
lcd.setCursor(5, 1); // Cursor na posição (coluna, linha)
lcd.print("+ LM35"); // Escreve esta string no LCD
delay(5000); // Delay de 5000 ms
lcd.clear(); // Limpa o display LCD
}

[38]
PRATICANDO COM SENSOR DE LUMINOSIDADE
O módulo sensor de luz utilizado no laboratório remoto (Figura 37), incorpora um Resistor
Dependente de Luz (LDR), ou seja, um resistor cuja resistência varia com a quantidade de luz
que incide sobre ele. Normalmente, a resistência do LDR ou Foto resistor diminuirá quando a
intensidade da luz ambiente aumentar. Isso significa que o sinal de saída deste módulo será
ALTO em luz brilhante, e BAIXO no escuro.
Um LDR é um sensor adequado para fornecer medições quantitativas no nível de luz, tanto
dentro quanto fora de casa, e reagindo, por exemplo, acendendo uma luz, levantando um
cego ou orientando um robô.

Figura 37: Módulo sensor de luminosidade

O módulo de sensor de luminosidade é de fácil uso e suas principais características são:

• A resistência diminui à medida que a luminância aumenta
• Baixa resistência (em luz brilhante) aciona um sinal HIGH em direção ao módulo de
saída
• Alta resistência (no escuro) aciona um sinal LOW em direção ao módulo de saída.
Em relação as especificações podem ser destacadas:
• Tensão: 3-5V
• Corrente de fornecimento: 0,5-3mA
• Resistência à luz: 20KΩ
• Resistência escura: 1MΩ
• Tempo de resposta: 20-30 segundos
• Comprimento de onda de pico: 540 nm
• Temperatura ambiente: -30~70°C
• LDR Usado: GL5528

O módulo sensor de luminosidade está conectado a porta analógica 0 (A0) do Arduino, como
mostrado na Figura 38.

[39]
 Figura 38: Conexão do módulo sensor de luminosidade ao shield

A seguir são apresentados alguns exemplos de código para praticar com o sensor de
luminosidade.
/* Exemplo de utilização do LDR
Neste exemplo utiliza-se as entradas digitais para piscar o módulo LED
enquanto o LDR recebe luz suficiente */
#include <math.h>
#define LED 2 // definir pino onde o LED esta conectado
const int LDRPin = 0;

void setup()
{
pinMode(LED, OUTPUT); // configura o pino LED como saída
pinMode(LDRPin, INPUT);
}

void loop()
{
int value = digitalRead(LDRPin);
if (value == HIGH)
{
digitalWrite(LED, HIGH); // Liga o led
delay(50);
digitalWrite(LED, LOW); // Desliga o LED
delay(50);
}
}

[40]
A Figura 39 mostra o programa em funcionamento no laboratório remoto “Ambiente de
Desenvolvimento para Arduino.

Figura 39: Programa em uso no laboratório remoto

[41]
Conhecendo um pouco mais um LDR
Um LDR (Light dependent resistor), ou fotoresistor, é um resistor cuja resistência depende da
intensidade de luz que incide sobre ele. Ou seja, é um sensor que age como uma resistência
variável dependendo da luz que captura. Quanto maior a intensidade da luz, menor a
resistência. Portanto, o LDR atua como um resistor variável. Os valores típicos são 1 MΩ para
escuridão total, e de 50-100Ω para luz brilhante.
Por outro lado, a variação de resistência é relativamente lenta, de 20 a 100ms dependendo
do modelo. Essa lentidão não permite registrar variações rápidas, como as produzidas em
fontes de luz artificial alimentadas pela corrente alternada. Esse comportamento pode ser
benéfico, pois dá ao sensor grande estabilidade.
A Figura 40 mostra um LDR e os símbolos utilizados na sua representação em circuitos
elétricos.

Figura 40: LDR e simbologia

Para saber a quantidade de luz que o sensor captura em um determinado ambiente, é

necessário medir a tensão de saída do sensor. Isso pode ser realizado através da utilização de
um circuito divisor de tensão, conforme mostrado na Figura 41. Assim, por meio de um par de
resistores em série, é possível distribuir a tensão fornecida pela fonte entre os terminais
destes, neste caso, o divisor é usado com a LDR para obter uma tensão variável de acordo com
a quantidade de luz percebida.

Figura 41: Divisor de tensão

Onde Vout é a voltagem lida pelo pino analógico do Arduino e que será convertida em um

[42]
valor digital, Vin é a tensão de entrada (5V), R2 será o valor do resistor fixo colocado
(geralmente 10KΩ) e R1 é o valor resistivo do sensor LDR. À medida que o valor do sensor LDR
varia, teremos uma fração maior ou menor da tensão de entrada Vin. Após a leitura do valor
na porta analógica do Arduino é realizada a Conversão Analógica-Digital (ADC), que é um
processo pelo qual uma magnitude física como tensão, corrente, temperatura, etc. é
convertida em um número binário (ou sinal digital) a fim de facilitar seu manuseio por circuitos
digitais, como uma CPU.

[43]
PRATICANDO COM UM SERVO MOTOR
Um servo (Figura 42) é um motor DC com engrenagens e sistema de retroalimentação. É usado
no mecanismo de condução de robôs, entre outras aplicações. Através de uma biblioteca
servo disponível na Arduino IDE, é possível ajustar os movimentos do servo para qualquer
posição entre 0 a 180 graus.

Figura 42: Servo motor

O servo motor utilizado no utilizado no laboratório remoto apresenta as seguintes

características mostradas no Quadro 3.
Quadro 3: Característica do servo utilizado no LR
Item Min Típica Max Unidade
Tensão de Trabalho 4,8 5,0 6,0 V
Torque 1,5/1,8 Kg.cm
Velocidade 0,12/0,16 s/60°
Tamanho 32X11.5X24 mm
Peso 8,5 g

O servo motor utilizado no laboratório remoto tem três fios: energia, terra e sinal. O fio de
alimentação é tipicamente o vermelho, e deve ser conectado ao pino de 5V na placa Arduino.
O fio de terra é tipicamente preto ou marrom e deve ser conectado a um pino de terra na
placa Arduino. O pino de sinal é tipicamente amarelo, laranja ou branco e no exemplo de
aplicação está conectado ao D5 na placa Arduino.
No exemplo vamos posicionar o eixo do servo para frente e para trás através de 180 graus
usando a Biblioteca Arduino Servo.
O servo motor está conectado a porta digital D5 do Arduino, como mostrado na Figura 43.

[44]
 Figura 43: Conexão do servo motor ao shield

/* Exemplo de utilização do servo motor */

#include <Servo.h>

Servo myservo; // criar um objeto servo para controlar o motor

// Na maioria das placas podem ser criados doze objetos servo

int pos = 0; // variável para armazenar a posição do servo

void setup() {
myservo.attach(5); // conecta o servo do pino 5 ao objeto servo
}

void loop() {
for (pos = 0; pos <= 180; pos += 1) { // vai de 0 graus a 180 graus
// em etapas de 1 grau
myservo.write(pos); // manda o servo ir para a posição
em variável 'pos'
delay(15); // espera 15ms para o servo chegar
à posição
}
for (pos = 180; pos >= 0; pos -= 1) { // vai de 180 graus a 0 graus
myservo.write(pos); // mandao servo para ir para a
posição em variável 'pos'
delay(15); // espera 15ms para o servo chegar
à posição
}
}

A Figura 44 mostra o programa em funcionamento no laboratório remoto “Ambiente de

Desenvolvimento para Arduino.

[45]
Figura 44: Programa em uso no laboratório remoto

[46]
Conhecendo os servos motores

Um servomotor é um dispositivo eletrônico muito parecido a um motor de corrente contínua,

mas que tem a capacidade de se mover em qualquer posição dentro do seu alcance de
operação, e manter-se estável nessa posição, permitindo controlar a velocidade de rotação.
Um servo motor é um equipamento eletromecânico que possui um encoder e um controlador
acoplado. Diferentemente de motores tradicionais, como de corrente contínua, o servo motor
apresenta movimento rotativo proporcional a um comando de forma a atualizar sua posição.
Ao invés de girar continuamente como os motores de corrente contínua, o servo, ao receber
um comando, gira até a posição especificada pelo mesmo. Ou seja, o servo motor é um
atuador rotativo para controle de posição, que atua com precisão e velocidade controlada em
malha fechada.
A Figura 45 mostra um típico servo motor. Trata-se do EMAX 9g ES08A, que é o modelo
utilizado no laboratório remoto.

Figura 45: Servo motor EMAX 9g ES08A mais conjunto de acessórios.

O servomecanismo utiliza um sinal de feedback de posição para controlar a velocidade e a

posição final do eixo do motor. O servo motor é composto pelos seguintes componentes
principais:
• Atuador: Consiste em um motor em conjunto com um sistema de engrenagens e
redução para amplificação de torque. A maioria dos servos utiliza motores de
corrente contínua, mas também há modelos que utilizam motores CA. Alguns servos
trabalham com atuadores de até 180º de liberdade de giro, outros modelos possuem
360º de liberdade de giro. Esse parâmetro, bem como a velocidade e o torque são
especificações que variam de modelo para modelo e devem ser analisadas para cada
aplicação;
• Sensor (encoder): O sensor consiste em um medidor de posição, geralmente um
potenciômetro acoplado ao eixo do motor, cuja resistência elétrica está associada a
posições diferentes do eixo do motor. Encoders também são utilizados para medir a
velocidade do motor;

[47]
 • Controlador e circuitos complementares: Este é o circuito de controle do servo
motor. A saída dos sensores é utilizada como realimentação e comparada com o sinal
de controle (posição e velocidade desejadas). A diferença dos dois sinais é o sinal de
controle utilizado pelo circuito controlador para corrigir a posição do atuador.
Os Servos são acionados por meio de três fios, dois para alimentação e um correspondente
ao sinal de controle para determinar a posição. No caso do EMAX 9g ES08A, os três fios são:
• Vermelho: Alimentação positiva;
• Marrom: GND;
• Laranja: Sinal de controle PWM;
Este motor faz rodar uma caixa de engrenagens (vide Figura 46) que reduzem a velocidade e
aumentam o movimento binário e por sua vez arrastam um potenciômetro que regula o
alcance de operação.

Figura 46: Ilustração da parte interna de um servo motor

Tipos de servo motores

Os servos motores são classificados de acordo com a natureza de sua alimentação. Ou seja,
podem ser servos CA ou CC. Os servomotores de corrente contínua são do tipo imã
permanente com escova e são utilizados em aplicações pequenas em razão de serem simples
e terem custo baixo.
Servos de corrente alternada, por sua vez, podem ser subdivididos em servos que
utilizam motores de indução (assíncronos) e servos que utilizam motores síncronos. Em geral
são maiores e de potência mais elevada, sendo comumente utilizados na indústria em
aplicações de maior potência e nas quais se exige maior robustez.
Aplicações dos servos motores
Os servos são utilizados em várias aplicações em que é preciso controlar posição com
precisão e velocidade altas. Tanto na indústria como no universo hobista os servos são muito
populares.
Dentre as principais aplicações podemos citar as seguintes:
• Aeromodelismo;

[48]
• Automodelismo;
• Robótica;
• Automação de processos;
• Controle de válvulas;
• Qualquer aplicação em que seja preciso controlar posição ou movimento.

[49]
REFERÊNCIAS
https://www.makerguides.com/tutorials/
https://www.arduino.cc/reference/pt/language/functions/time/delay/
https://www.ingmecafenix.com/category/electronica/

[50]
 Laboratório de Experimentação Remota
Universidade Federal de Santa Catarina – Campus Araranguá

https://rexlab.ufsc.br/

rexlab@contato.ufsc.br
rexlabufsc@gmail.com

Siga-nos nas redes sociais e fique por dentro de todas as nossas ações.

[51]