Curso de arduino basico

Prévia do material em texto

Universidade Federal do Vale do São Francisco 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 JUAZEIRO-BA 
 2017 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
Considerações iniciais 
Este material foi elaborado por Mauro Sérgio de Araújo Oliveira Filho, 
graduando em engenharia elétrica na Universidade Federal do Vale do São 
Francisco em 2017. 
Este material foi gerado com base em outros muitos materiais que são 
citados no desenvolvimento desta apostila. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
SUMÁRIO 
1. INTRODUÇÃO 
 
 O que é um Arduino, e por que usá-lo 
 Partes principais de um Arduino 
 Instalando o Software 
 Como usar a IDE 
 
2. LINGUAGEM DE PROGRAMAÇÃO C 
 
 Variáveis e constantes 
 Operadores e Especificidades 
 Estruturas de controle de fluxo 
 Estruturas de repetição 
 
3. PROGRAMAÇÃO NA IDE 
 
 Estruturas fundamentais 
 Bibliotecas e Funções principais 
 
4. PROJETOS 
 
CURSO BÁSICO 
 Parte 1: LED’s 
Projeto 1: LED piscante 
Projeto 2: Sinalizador de código Morse 
Projeto 3: Semáforo Simples 
Projeto 4: Semáforo Interativo 
Projeto 5: Efeito de iluminação sequencial 
Projeto 6: Iluminação sequencial controlada 
 
CURSO INTERMEDIARIO 
 Parte 2: Sensores e receptação de dados 
Projeto 7: LDR 
Projeto 8: Sensor Ultrassônico 
 Parte 3: Atuadores 
Projeto 9: Servo Motor 1 
Projeto 10: Servo Motor 2 
Projeto 11: motor de passo 
Projeto 12: motor CC simples 
 Parte 4: Comunicação Serial 
Projeto 11: Display de Cristal Liquido 
 
CURSO AVANÇADO 
 Parte 5: interrupções 
 Parte 6: programação com Atmel Studio 
 Parte 7: Shields e “internet das coisas” 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
 
1- INTRODUÇÃO: 
Antes que começarmos a simplesmente usar um Arduino devemos nos 
perguntar “O que é um Arduino?” ou “Por que usar um Arduino?”. Desde que o 
Projeto Arduino teve inicio em 2005 a utilização destas plaquinhas para inúmeras 
finalidades se difundiu muito rapidamente, mas por que? A plataforma Arduino surgiu 
em 2005, feito por Massimo Benzi, David Cuartielles, Tom Igoe, Gianluca Martino e 
David Mellis, com o objetivo de criar um dispositivo para controlar projetos 
construídos de uma forma mais acessível e simples do que outros sistemas 
disponíveis no mercado. (SARIK; KYMISSIS, 2010), sendo um dos grandes fatores 
de difusão a disponibilidade de portal com o aplicativo e tutoriais. Este uso deve-se 
ao fato que é possível ler dados de qualquer fenômeno detectável por sensores, ou 
seja, basicamente é um sistema que lê sinais elétricos em sensores expostos ao 
ambiente a partir de suas portas digitais e analógicas, e envia sinais elétricos para 
atuadores que respondem ao estimulo detectado. 
 É uma plataforma open source que usa hardware aberto de baixo custo e 
software livre e pode ser conectada com um computador através de uma porta USB 
(ARDUINO, 2016). Possui um microcontrolador e todos os periféricos necessários 
para a programação e utilização do mesmo. A programação do microcontrolador 
presente na plataforma Arduino é feita a partir de qualquer computador que possua 
o software da plataforma instalado. (MCROBERTS, 2011) 
Em termos práticos, um Arduino é um pequeno computador que você pode 
programar para processar entradas e saídas entre o dispositivo e os componentes 
externos conectados a ele (Figura 1.1). O Arduino é o que chamamos de plataforma 
de computação física ou embarcada, ou seja, um sistema que pode interagir com 
seu ambiente por meio de hardware e software. (MCROBERTS, 2011) 
 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
1.1- HARDWARE: 
(Texto modificado extraído da Revista Saber Eletrônica; Ano 47; N° 454 – 2011; 
Editora Saber LTDA Páginas 12 a 15. Autor Filipe Pereira) 
 
Apresentação do Arduino: 
 É uma placa microcontroladora baseada no microcontrolador ATmega 328. 
Ela tem 14 pinos I/O digitais, 6 entradas analógicas, um oscilador de 16 MHz (a 
cristal), uma conexão USB, um jaque de alimentação, um header ICSP, e um botão 
de reset. Ela contém tudo o que é necessário para o suporte do μC 
(microcontrolador), ligando-a simplesmente a um computador através de um cabo 
USB, ou alimentando-a com um adaptador AC/AD (ou bateria) para dar a partida. 
Memória 
O ATmega328 tem 32 KB de memória flash para armazenar código (dos 
quais 2 KB são utilizados pelo bootloader), além de 2 KB de SRAM e 1 KB de 
EEPROM (Electrically-Erasable Programmable Read-Only Memory), que pode ser 
lida e escrita através da biblioteca EEPROM. 
Alimentação 
O Arduino pode ser alimentado pela ligação USB ou por qualquer fonte de 
alimentação externa. A fonte de alimentação é selecionada automaticamente. 
Alimentação externa (não USB) pode ser tanto de uma fonte como de uma bateria. 
A fonte pode ser ligada com um plugue de 2,1 mm (centro positivo) no conector de 
alimentação. 
Outra forma de alimentar o Arduino é usando cabos vindos de uma bateria 
podem ser inseridos nos pinos GND (massa) e Vin (entrada de tensão) do conector 
de alimentação. 
 
A placa pode funcionar com uma alimentação externa de 6 a 20 volts. 
Entretanto, se a alimentação for inferior a 7 volts, o pino 5 V pode fornecer menos de 
5 volts e a placa poderá ficar instável. Se a alimentação for superior a 12 volts, o 
regulador de tensão poderá sobreaquecer e avariar a placa. A alimentação 
recomendada é de 7 a 12 volts. 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
Os pinos de alimentação são: 
 VIN - Entrada de alimentação para a placa Arduino quando uma fonte externa 
for utilizada. Poder-se-á fornecer alimentação por este pino ou, se for usar o 
conector de alimentação, empregar a alimentação por este pino. 
 5V - A fonte de alimentação utilizada para o microcontrolador e para outros 
componentes da placa pode ser proveniente do pino Vin através de um 
regulador on-board, ou ser fornecida pelo USB ou outra fonte de 5 volts. 
 3V3 - Alimentação de 3,3 volts fornecida pelo chip FTDI. A corrente máxima 
é de 50 mA. 
 GND - Pino terra ou massa. 
Portas de Entrada e Saída 
 Analógico: 
O Arduino tem 6 entradas analógicas e cada uma delas tem uma resolução 
de 10 bits (i.e. 1024 valores diferentes). Por padrão, elas medem de 0 a 5 volts, 
embora seja possível mudar o limite superior usando o pino AREF e um pouco de 
código de baixo nível (veremos a frente). Adicionalmente alguns pinos têm 
funcionalidades específicas, a saber: 
 AREF - Referência de tensão para entradas analógicas. São usados com o 
analogReference(). 
 
 Digital: 
Cada um dos 14 pinos digitais do Arduino pode ser utilizado como entrada 
ou saída, usando as funções de pinMode(), digitalWrite(), e digitalRead() ,(veremos 
isso melhor mais a frente). Eles trabalham com 5 volts. Cada pino pode fornecer ou 
receber um máximo de 40 mA e tem uma resistência de pull-up interna (vem 
desligada de fábrica) de 20-50 kΩ. 
Alguns pinos têm funções específicas: 
 Serial: 0 (RX) e 1 (TX): são usados para receber (RX) e transmitir (TX) dados 
série, TTL. Estes pinos são ligados aos pinos correspondentes do chip serial 
FTDI USB-to-TTLUniversidade Federal do Vale do São Francisco 
 
 
 
 External Interrupts: 2 and 3 - Estes pinos podem ser configurados para ativar 
uma interrupção por um baixo valor, uma elevação ou falling edge ou uma 
mudança de valor. Veja a função attachInterrupt() para mais pormenores. 
 PWM: 3, 5, 6, 9, 10, e 11 - Fornecem uma saída analógica PWM de 8-bit com 
a função analogWrite(). 
 SPI: 10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK) - Estes pinos suportam 
comunicação SPI, que embora compatível com o hardware, não está incluída 
na linguagem do Arduino. 
 LED: 13 - Há um LED já montado e ligado de origem ao pino digital 13. 
Quando o pino está no valor HIGH, o LED acende; quando o valor está em 
LOW, ele apaga. 
 
1.2- SOFTWARE: 
Para programar o Arduino (fazer com que ele faça o que você deseja) você 
utiliza o IDE do Arduino, um software livre no qual você escreve o código na 
linguagem que o Arduino compreende (baseada na linguagem C). O IDE permite que 
você escreva um programa de computador, que é um conjunto de instruções passo 
a passo, das quais você faz o upload para o Arduino. Seu Arduino, então, executará 
essas instruções, interagindo com o que estiver conectado a ele. No mundo do 
Arduino, programas são conhecidos como sketches (rascunho, ou esboço). 
(MCROBERTS, 2011) 
 
Como instalar a IDE: 
Antes de qualquer coisa você deve acessar o site oficial da plataforma 
Arduino https://www.arduino.cc/en/Main/Software e efetuar o download da versão 
mais atual da IDE. Escolha o arquivo compatível com seu sistema operacional, seja 
ele Windows, Linux ou Mac, e então siga as instruções de instalação para seu 
sistema. 
(As instruções de instalação a seguir foram integralmente retiradas do livro: Arduino 
Básico, páginas 27 e 28. Autor: Michael McRoberts) 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
Instalação no Windows XP: 
Assim que você tiver feito o download do IDE mais recente, descompacte o 
arquivo e clique duas vezes na pasta descompactada para abri-la. Você verá os 
arquivos do Arduino e suas subpastas. A seguir, conecte seu Arduino utilizando o 
cabo USB e verifique se o LED verde de energia (PWR) acende. O Windows lhe 
avisará “Novo hardware encontrado: Arduino” e o Assistente de instalação de novo 
hardware será exibido. Clique Avançar e o Windows tentará carregar os drivers. Esse 
processo falhará, mas não se preocupe, isso é normal. Em seguida, clique com o 
botão direito no ícone Meu Computador em seu Desktop e escolha gerenciar. A 
janela de Gerenciamento do Computador abrirá. Agora, desça até o Gerenciador de 
Dispositivos, na lista Ferramentas do Sistema, e clique nele. Na janela, à direita, você 
verá uma lista de seus dispositivos. O Arduino Uno fará parte 
dessa lista com um ponto de exclamação amarelo sobre ele, para indicar que 
o dispositivo não foi instalado corretamente. Clique com o botão direito sobre esse 
ícone e escolha “Atualizar Driver”. Escolha “Não, não agora” na primeira página e 
clique em Avançar. Então, escolha “Instalar de uma lista ou local específico 
(avançado)” e clique novamente em Avançar. Agora clique em “Incluir este local na 
pesquisa” e clique em Procurar. Navegue até a pasta Drivers do IDE descompactado 
do Arduino e clique em Avançar. O Windows instalará o driver e você poderá, então, 
clicar no botão Concluir. O Arduino Uno agora será exibido na opção Portas (COM 
& LPT), na lista de dispositivos, e mostrará o número de porta atribuído a ele (por 
exemplo, COM6). Para abrir o IDE, clique duas vezes no ícone do Arduino em sua 
pasta. 
 
Instalação no Windows 7 e Vista: 
Assim que você tiver feito o download do IDE mais recente, descompacte o 
arquivo e clique duas vezes na pasta descompactada para abri-la. Você verá os 
arquivos do Arduino e suas subpastas. A seguir, conecte seu Arduino utilizando o 
cabo USB e verifique se o LED verde de energia (PWR) acende. O Windows tentará 
instalar automaticamente os drivers para o Arduino Uno e falhará. Isso é normal, por 
isso, não se preocupe. Clique no botão Iniciar do Windows e depois em Painel de 
Controle. Agora, clique em Sistema e Segurança, depois em Sistema e, então, em 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
Gerenciador de Dispositivos, na lista, no lado esquerdo. O Arduino fará parte da lista 
como um dispositivo com um ponto de exclamação amarelo sobre ele, para mostrar 
que não foi instalado corretamente. Clique com o botão direito no Arduino Uno e 
escolha Atualizar driver. Depois, escolha Procurar software de driver no computador 
e, na janela seguinte, clique no botão Procurar. Navegue até a pasta Drivers dentro 
da pasta Arduino que você descompactou antes e clique em OK, e depois em 
Avançar. O Windows tentará instalar o driver. Uma caixa de segurança do Windows 
será exibida afirmando que o “Windows não pode verificar o editor deste software de 
driver”. Clique em Instalar driver mesmo assim. A janela de instalação fará o 
necessário. Se tudo der certo, você terá outra janela dizendo que 
o software de driver foi atualizado com êxito. Finalmente, clique em Fechar. 
Para abrir o IDE, clique duas vezes no ícone do Arduino em sua pasta. 
 
Instalação no Mac OSX: 
Faça o download do arquivo de imagem de disco (.dmg) mais recente para 
o IDE.Abra o arquivo .dmg (Figura 1). 
 
 
Figura 1– Arquivo. dmg do Arduino aberto no OSX. 
 
Arraste o ícone do Arduino sobre a pasta Aplicações, soltando-o nela. Se 
você estiver utilizando um Arduino mais antigo, como o Duemilanove, terá de instalar 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
o driver FTDI USB Serial. Clique duas vezes no ícone do pacote e siga as instruções 
para fazê-lo. Para o Uno e o Mega 2560, não será necessário instalar nenhum driver. 
 
Como usar a IDE: 
Se você já baixou e instalou a IDE do Arduino e já possui uma placa em 
mãos sugiro que seu próximo passo seja associar o seu hardware ao software, 
conectando seu sua placa a um computador (com a IDE instalada) e selecionando 
placa e porta. 
 
Seleção de placa e porta: 
Primeiro abra sua IDE, e conecte sua placa ao computador utilizando o 
cabo de dados, então vá até o menu e clique em “ferramentas”, em seguida 
aparecerá uma lista de ações, clique em “placa”, lhe será apresentado uma lista de 
placas, escolha a sua placa em questão. Podemos ver todo este procedimento na 
figura 2: 
 
Figura 2: Seleção de placa na IDE 
 
Ainda em ferramentas clique na opção “porta”, aparecerá as opções, escolha a porta serial 
correspondente a placa que esta utilizando, como ilustrado na figura 3: 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
Figura 3: Seleção de porta na IDE 
 
Agora seu Arduino está pronto para que você comece a programá-lo, mas 
antes é importante dar uma volta pela IDE e conhecer seus principais comandos 
básicos, que irão lhe auxiliar muito durante seus futuros projetos. 
 
Como Utilizar a IDE: 
Ao abrir a IDE você verá no topo a “barra de menus”, logo a baixo, a “barra 
de ferramentas”, então haverá um espaço onde seu código é escrito e por fim a 
“janela de mensagem” na parte de baixo. Cada um desses itens é muito importante 
e veremos como utilizar corretamente cada um deles a seguir. 
Barra de Menus: 
No topo da do programa encontramos uma barra fina com alguns botões que 
são os “menus” do software, são eles: “arquivo”, “editar”, “sketch”, “ferramentas” e 
“ajuda”,como podemos ver na figura 4. 
 
 
Figura 4: Barra de “menus” 
 
 
O primeiro menu na barra é o “arquivo”, nele você terá acesso a funções que 
lhe permitem iniciar um novo código ou abrir um código anteriormente salvo, abrir 
exemplos de código simples, muito úteis para iniciantes.Você ainda poderá salvar 
um código que está escrevendo ou imprimi-lo, como vemos na figura 5: 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
 
Figura 5: Menu “arquivo”. 
 
O segundo menu é o “editar” lhe dá opções para configurar seu código, 
copiar ou colar partes, selecionar todo o código, desfazer ou refazer ações, 
acrescentar comentários, localizar palavras, entre outros, como podemos ver na 
figura 6: 
 
 
Figura 6: Menu “editar” 
 
O próximo menu é o “sketch”, neste menu você encontra ações para 
avaliação e envio do seu código, podendo verificar se há alguma incoerência no seu 
código ou erro de sintaxe, bem como carregar o código na placa, pode importar uma 
biblioteca especifica entre outras ações menos utilizadas. O menu “sketch” é 
representado abaixo pela figura 7. 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
 
Figura 7: Menu “sketch”. 
 
Na sequência encontramos o menu “ferramentas”, representado pela figura 
8, neste podemos usar a função “autoformatação” para editar o código de forma que 
melhore a visualização e compreensão, temos também como compactar o código 
em um arquivo com formato ZIP, podemos optar por realizar as correções de sintaxe 
automaticamente, selecionar a placa e a porta que estamos utilizando em dado 
momento com fizemos na sessão de instalação.Podemos ainda utilizar a opção 
“gravar bootloader” para gravar em um chip em branco o Arduino Bootloader (trecho 
de código do chip que permite compatibilidade com a IDE), apesar de normalmente 
valer mais a pena comprar um ATmega pré-programado. 
 
 
Figura 8: Menu “ferramentas” 
 
O ultimo menu da barra é o menu “ajuda”, neste você encontrará opções de 
apoio para resolução de possíveis problemas com a utilização da IDE, um fórum de 
perguntas frequentes, link para acesso a pagina oficial do Arduino na internet, e 
informações sobre a plataforma. Podemos observar o menu ajuda na figura 9. 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
Figura 9:Menu “ajuda”. 
 
Barra de Ferramentas: 
 
A barra de ferramentas tem os botões de ações essenciais para a utilização 
corriqueira, provavelmente sempre que você usar a IDE irá utilizar algum esses 
botões, por esse motivo existe essa barra de acesso rápido. Nesta barra você 
encontrará os botões verificar, carregar, sketch novo, abrir, salvar e monitor serial. 
Todos eles estão representados da figura 10 
 
 
 
Figura 10: Barra de Ferramentas 
 
 O botão Verificar faz uma checagem no código a procura de erros de sintaxe 
ou estruturas incoerentes 
 O botão Carregar envia o código para a placa 
 O botão Novo Sketch abre uma nova guia em branco 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 O botão Abrir lhe direciona a uma lista de sketches salvos que você poderá 
escolher para exibir e utilizar 
 O botão Salvar, como o próprio nome já indica, salva seu sketch 
 O botão Monitor Serial inicializa a comunicação serial e abre uma quia para 
um monitor de comunicação com sua placa. 
 
Janela de mensagem: 
 
Tudo que você precisa saber sobre a janela de mensagem é que se você 
cometer algum erro seja este erro na escrita do código, ou na escolha da porta, ou 
se você esqueceu de conectar a placa antes de carregar o código, aparecerá então 
alguma mensagem para você lhe avisando do erro, e muitas vezes indicando qual 
foi o erro. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
2- LINGUAGEM DE PROGRAMAÇÃO EM C. 
 
(esta sessão é uma adaptação, seu conteúdo base foi retirado integralmente de: 
Curso de Linguagem C UFMG, páginas 17 á 21, autor Daniel Balparda de Carvalho) 
 
2.1- Variáveis e Constantes: 
 
Nomes de Variáveis 
 
As variáveis no C podem ter qualquer nome contanto que determinadas condições 
forem satisfeitas: 
 O nome deve começar com uma letra ou sublinhado (_) 
 Os caracteres subsequentes devem ser letras, números ou sublinhado (_). 
 O nome de uma variável não pode ser igual a uma palavra reservada, que 
podem ser conferidas na figura 11, 
 Nem igual ao nome de uma função declarada pelo programador, ou pelas 
bibliotecas do c. 
 Variáveis devem ter até 32 caracteres para serem aceitas. 
 Mais uma coisa: é bom sempre lembrar que o c diferencia maiúsculas de 
minúsculas. 
 
Figura 11: lista de palavras reservadas 
 
 Dicas quanto aos nomes de variáveis... 
 
É uma prática tradicional do C, usar letras minúsculas para nomes de variáveis 
e maiúsculas para nomes de constantes. Isto facilita na hora da leitura do 
código; 
Quando se escreve código usando nomes de variáveis em português, evitam-
se possíveis conflitos com nomes de rotinas encontrados nas diversas 
bibliotecas, que são em sua maioria absoluta, palavras em inglês. 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
Os Tipos do C 
 
Como assim tipos? Na linguagem de programação C os tipos determinam 
que tipo de “coisa” sua constante, variável ou função pode receber. É uma forma 
simples de agrupar os dados de forma organizada ao passo que se economiza 
memória, uma vez que é possível escolher variáveis mais “leves” para dados mais 
simples, como números inteiros, ou variáveis mais “pesadas” para dados mais 
complexos como palavras, números fracionários ou números enormes. É possível 
ainda definir com a escolha do tipo uma maior precisão para a captação de dados 
de uma dada variável, ou determinar uma precisão menor para outra variável que 
não precise de um tratamento de dados minucioso. O mais importante é que tudo é 
feito simultaneamente em um mesmo programa, sem maiores especificações e 
complicações. 
 
O C tem 5 tipos básicos: char, int, float, void, double. 
 O tipo char é o tipo de variável que pode receber caracteres, ou seja, letras, 
palavras entre outros. 
 O tipo int recebe números inteiros positivos e negativos. 
 O tipo float recebe números fracionários, ou seja, qualquer numero com parte 
decimal, é chamado também de “ponto flutuante”. 
 O double é o “ponto flutuante” duplo e pode ser visto como um ponto flutuante 
com muito mais precisão. 
 O void é o tipo vazio, ou um "tipo sem tipo". A aplicação deste "tipo" será vista 
posteriormente. 
 
Para cada um dos tipos de variáveis existem os modificadores de tipo. Os 
modificadores de tipo do C são quatro: signed, unsigned, long e short. 
Ao float não se pode aplicar nenhum e ao double pode-se aplicar apenas o 
long. Os quatro modificadores podem ser aplicados a inteiros. A intenção é que 
short e long devam prover tamanhos diferentes de inteiros, onde isto for prático. 
Inteiros menores (short) ou maiores (long). O modificador unsigned serve para 
especificar variáveis sem sinal. Um unsigned int será um inteiro que assumirá 
apenas valores positivos. Na figura 12 estão listados os tipos básicos de dados 
permitidos, a quantidade de bits que ocupam na memória, e seus valores máximose mínimos em um compilador típico para um hardware de 16 bits. 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
Figura 12: tabela de tipos e modificadores 
 
 
ATENÇÃO: Muitas vezes ao escrevermos um programa não nos preocupamos 
com a memória que estamos ocupando com determinado código, isso porque a 
memória dos computadores atuais é grande o suficiente para não precisarmos 
nos preocupar. Mas lembre que seu Arduino não é um ultrabook, portanto 
cuidado com suas variáveis, constantes e funções, ou o Arduino não irá 
comportar o programa. 
 
 
 
Declaração e Inicialização de Variáveis: 
As variáveis no C devem ser declaradas antes de serem usadas. A forma 
geral da declaração de variáveis é: 
tipo_da_variável Nome_da_variáveis; 
Exemplo 1: 
 Int PotPin; 
 Float PotValor; 
 
Qual a diferença entre “variáveis” e “constantes”? Basicamente as “variáveis” 
são variáveis e as “constantes” são constantes! 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
As variáveis e constantes em C são declaradas da mesma forma, porém as 
constantes recebem logo um valor fixo e em geral permanecem com este valor até 
o final do seu código, por outro lado as variáveis podem ser vistas como uma caixa 
vazia, que conforme o programa for se desenvolvendo ela irá sendo preenchida com 
dados que são periodicamente substituídos ou atualizados conforme seja 
necessário. E m geral utilizamos constantes para nomear portas analógicas e 
digitais, ou processos semelhantes, já variáveis são utilizadas para receber dados 
de leitura das portas, criar contadores, iniciar ou findar processos, entre outras 
incontáveis ações que ficarão mais calaras na parte da programação na IDE. 
Exemplo 2: (exemplo de declaração) 
Constante: 
Int PotPin = 1; 
Estou especificando que o pino 1 será chamado de PotPin, e isso será fixo, 
PotPin será sempre o nome da porta 1 e isso não irá mudar independente de quantas 
vezes o código for executado, o que faz de PotPin uma constante. 
Variável: 
Int PotValor 
PotValor = AnalogRead(PotPin); 
Primeiro declaro minha variável PotValor sem atribuir a ela um valor fixo, 
depois minha variável irá receber a leitura do pino que chamei inicialmente de PotPin, 
como foi expresso na situação, essa leitura pode variar a cada vez que o código for 
executado, por isso PotValor é uma variavel. 
 
 
Figura 13: tabela de constantes e valores 
 
 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
2.2- Operadores e Especificidades: 
 
O C utiliza sinais para tornar a escrita e leitura do código mais lógica e rápida, 
estes símbolos serão nesta apostila divididos em 4 grupos básicos, são eles: 
Operadores Aritméticos, Operadores Lógicos,Operadores Barra Invertida e 
Operadores Porcento. 
Operadores: 
Operadores Aritméticos: 
Utilizando os operadores aritméticos é possível no desenvolvimento do seu 
código somar, subtrair, dividir, multiplicar, incrementar e decrementar suas 
constantes e a partir disso gerar equações com suas variaveis. 
 
Figura 13: Operadores Aritméticos 
 
Operadores Lógicos: 
Em diversas situações durante o desenvolvimento de um programa você irá 
precisar, agrupar, associar ou comprar dados de suas variáveis ou entre variáveis e 
constantes, para isso utiliza-se os operadores lógicos listados nas figuras 14 e 15. 
 
Figura 14: Operadores lógicos 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
Figura 15: Operadores Lógicos comparativos 
 
Operadores Barra Invertida (\): 
Os chamados códigos de barra invertida. Estes são caracteres que podem ser 
usados como qualquer outro. Uma lista com alguns dos códigos de barra invertida é 
dada a seguir: 
 
 
Figura 16: Tabela de barra invertida 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
Operadores Porcento (%): 
 
Os operadores porcento são utilizados para referir-se em á uma variável para 
recepção de caracteres em funções como scanf() ou printf(), os operadores 
porcento estão listados na figura 17. 
 
 
Figura 17: Tabela operadores porcento. 
 
 
Especificidades: 
 
Expressões simplificadas: 
Muitas expressões são reduzidas para tornar a escrita mais prática. 
 
Figura 18: Tabela de simplificações 
 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
Modeladores (Casts): 
Basicamente significa converter os tipos para realizar expressões com 
operadores, a conversão é feita como representado a seguir: 
(tipo)expressão 
Exemplo: 
 f=(float)num/7; 
 /* Uso do modelador . Força a transformação de num em um float */ 
 
Tabela de Precedências do C: 
Esta é a tabela de precedência dos operadores em C. Alguns (poucos) 
operadores ainda não foram estudados, e serão apresentados em aulas posteriores. 
Maior precedência 
() [] -> 
! ~ ++ -- 
(cast) 
* / % 
+ - 
== != 
& 
^ 
| 
&& 
|| 
? 
= += -= *= /= 
Menor precedência 
 
 
Uma dica aos iniciantes: Você não precisa saber toda a tabela de precedências e 
cor. É útil que você conheça as principais relações, mas é aconselhável que ao 
escrever o seu código, você tente isolar as expressões com parênteses, para tornar 
o seu programa mais legível. 
Importante lembrar: Toda linha em C deve ser finalizada com ponto e virgula (;) e 
todas as ações que devem ocorrer dentro dos domínios de uma função devem estar 
entre chaves ({}). 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
2.3- Estruturas de controle de fluxo: 
 
As estruturas de controle de fluxo são fundamentais para qualquer 
linguagem de programação. Sem elas só haveria uma maneira do programa ser 
executado: de cima para baixo comando por comando. Não haveria condições, 
repetições ou saltos. A linguagem C possui diversos comandos de controle de fluxo. 
É possível resolver todos os problemas sem utilizar todas elas, mas devemos nos 
lembrar que a elegância e facilidade de entendimento de um programa dependem 
do uso correto das estruturas no local certo. 
O Comando IF: 
Sua forma geral é: 
if (condição) {declaração}; 
A expressão, na condição, será avaliada. Se ela for zero, a declaração não 
será executada. Se a condição for diferente de zero a declaração será executada. 
Como podemos ver no diagrama da figura 
O Else: 
Podemos pensar no comando else como sendo um complemento do 
comando if. O comando if completo tem a seguinte forma geral: 
if (condição) {declaração_1} else {declaração_2}; 
A expressão da condição será avaliada. Se ela for diferente de zero a 
declaração 1 será executada. Se for zero a declaração 2 será executada. É 
importante nunca esquecer que, quando usamos a estrutura if-else, estamos 
garantindo que uma das duas declarações será executada. Nunca serão executadas 
as duas ou nenhuma delas. 
O If-Else-If: 
 
A estrutura if-else-if é apenas uma extensão da estrutura if-else. Sua forma geral 
pode ser escrita como sendo: 
if (condição_1) {declaração_1 
}else{ if (condição_2) {declaração_2 
}else {if (condição_3) {declaração_3 
. 
. 
}else{ if (condição_n) {declaração_n; 
}else {declaração_default}; 
 
 Universidade Federal do Vale do São FranciscoA estrutura acima funciona da seguinte maneira: o programa começa a testar 
as condições começando pela 1 e continua a testar até que ele ache uma expressão 
cujo resultado dê diferente de zero. Neste caso ele executa a declaração 
correspondente. Só uma declaração será executada, ou seja, só será executada a 
declaração equivalente à primeira condição que der diferente de zero. A última 
declaração (default) é a que será executada no caso de todas as condições darem 
zero e é opcional. 
 
O Comando Switch: 
O comando if-else e o comando switch são os dois comandos de tomada 
de decisão. Sem dúvida alguma o mais importante dos dois é o if, mas o comando 
switch tem aplicações valiosas. Mais uma vez vale lembrar que devemos usar o 
comando certo no local certo. Isto assegura um código limpo e de fácil entendimento. 
O comando switch é próprio para se testar uma variável em relação a diversos 
valores pré-estabelecidos. Sua forma geral é: 
switch (variável){ 
case (constante_1): 
declaração_1; 
break; 
case (constante_2): 
declaração_2; 
break; 
. 
. 
. 
case (constante_n): 
declaração_n; 
break; 
(default) 
declaração_default;} 
 
Podemos fazer uma analogia entre o switch e a estrutura if-else-if 
apresentada anteriormente. A diferença fundamental é que a estrutura switch não 
aceita expressões. Aceita apenas constantes. O switch testa a variável e executa a 
declaração cujo case corresponda ao valor atual da variável. A declaração default 
é opcional e será executada apenas se a variável, que está sendo testada, não for 
igual a nenhuma das constantes. 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
O comando break, faz com que o switch seja interrompido assim que uma 
das declarações seja executada. Mas ele não é essencial ao comando switch. Se 
após a execução da declaração não houver um break, o programa continuará 
executando. Isto pode ser útil em algumas situações, mas é preciso muito ter 
cuidado. 
As figuras 19 e 20 resumem em um esquema simples a lógica das estruturas 
de controle de fluxo. 
(As figuras abaixo foram retiradas da apostila: Arduino: Cartilha para 
programação em C, páginas 7 e 8. Autor: João Alexandre Silveira) 
 
 
 
Figura 19: Esquema If e Else. 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
Figura 20: Esquema If-Else-If e Switch-Case 
 
2.4- Estruturas de repetição: 
Em muitas situações precisamos realizar a repetição de um determinado 
trecho do código até que determinada condição seja satisfeita, ou simplesmente 
repetir um numero finito ou até mesmo infinito de vezes. Pra isso utilizamos as 
estruturas de repetição. As estruturas de repetição no C são 3 tipos: For, While e Do-
While. 
O Comando For: 
Como já foi dito, o loop for é usado para repetir um comando, ou bloco de 
comandos, diversas vezes, de maneira que se possa ter um bom controle sobre o 
loop. Sua forma geral é: 
for (inicialização;condição;incremento) declaração; 
O melhor modo de se entender o loop for é ver como ele funciona "por dentro". O 
loop for é equivalente a se fazer o seguinte: 
inicialização; 
if (condição) 
{ 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
declaração; 
incremento; 
"Volte para o comando if" 
} 
 
Podemos ver, então, que o for executa a inicialização incondicionalmente e 
testa a condição. Se a condição for falsa ele não faz mais nada. Se a condição for 
verdadeira ele executa a declaração, faz o incremento e volta a testar a condição. 
Ele fica repetindo estas operações até que a condição seja falsa. 
Um ponto importante é que podemos omitir qualquer um dos elementos do 
for, isto é, se quisermos gerar um loop infinito basta omitir a condição, assim 
qualquer valor inicializado ou incrementado irá satisfazer o for, se quisermos omitir 
a inicialização podemos utilizar uma variável q já estava sendo usada no código e já 
possuía um valor, bem como podemos retirar o incremento fazendo com que não 
haja contador, para o numero de repetições se este não for necessário. Podemos 
muitas vezes utilizar o for com a finalidade de contar ou de atrasar o programa e 
então podemos gerar uma estrutura sem a declaração. 
 
O Comando while 
O comando while tem a seguinte forma geral: 
while (condição) declaração; 
Assim como fizemos para o comando for, vamos tentar mostrar como o 
while funciona fazendo uma analogia. Então o while seria equivalente a: 
if (condição) 
{ 
declaração; 
"Volte para o comando if" 
} 
Podemos ver que a estrutura while testa uma condição. Se esta for 
verdadeira a declaração é executada e faz-se o teste novamente, e assim por diante. 
Assim como no caso do for, podemos fazer um loop infinito. Para tanto basta colocar 
uma expressão eternamente verdadeira na condição, ou simplesmente omiti-la. 
Pode-se também omitir a declaração e fazer um loop sem conteúdo. 
 
O Comando Do-While 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
A terceira estrutura de repetição que veremos é o do-while de forma geral: 
do{ 
declaração; 
} while (condição); 
Mesmo que a declaração seja apenas um comando é uma boa prática deixar 
as chaves. O ponto-e- vírgula final é obrigatório. Vamos, como anteriormente, ver o 
funcionamento da estrutura do-while "por dentro": 
declaração; 
if (condição) "Volta para a declaração" 
Vemos pela análise do bloco acima que a estrutura do-while executa a 
declaração, testa a condição e, se esta for verdadeira, volta para a declaração. A 
grande novidade no comando do-while é que ele, ao contrário do for e do while, 
garante que a declaração será executada pelo menos uma vez. 
 
Observação: Algo que pode ajudar a entender os comandos while e do-while é seu 
significado. A tradução para “while” é enquanto e para “do” é fazer. Portanto o 
comando while diz ao programa, enquanto a condição for verdadeira execute as 
ações presentes na declaração, por sua vez o comando do-while primeiro diz “faça” 
ou “execute” as ações da declaração e so depois de executar a primeira vez é que 
ele diz que enquanto a condição for verdadeira deve-se fazer tudo outra vez. 
 
As figuras 21 e 22 resumem em um esquema simples a lógica das estruturas 
de repetição. 
(As figuras abaixo foram retiradas da apostila: Arduino: Cartilha para 
programação em C, páginas 9 e 10. Autor: João Alexandre Silveira) 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
Figura 21: esquema While e Do-While. 
 
 
Figura 22: Esquema For. 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
3- PROGRAMAÇÃO NA IDE: 
A IDE do Arduino utiliza uma variação da linguagem C em uma estrutura de 
definição e repetição que facilita muito a utilização para seus fins. Para facilitar ainda 
mais existe uma infinidade de bibliotecas que contem funções dos mais diversos 
tipos simplificando a utilização de sensores, motores, painéis, módulos entro outros. 
Ou seja programar na IDE do Arduino é bem simples e é isso que veremos nesta 
sessão. 
 
3.1- estruturas básicas: 
Como podemos ver na figura 23 o a IDE divide o seu código em três partes 
principais, na primeira delas você deve incluir todas as bibliotecas que deseja utilizar, 
inicializar todas variáveis e constantes que deseja que sejam vistas portodas as 
funções do seu programa, nesta parte do código deve-se também fazer a declaração 
de uma função que eventualmente foi criada por você e está situada no final do 
código (como se é padronizado). 
 
Depois de haver incluído todas as bibliotecas devemos então utilizar a parte 
interna da função void setup para definir os pinos digitais como portas de entrada 
ou de saída, inicializar (se for o caso) o portal serial, ou atribuir valores iniciais para 
variáveis que no decorrer do código terão este valor alterado inúmeras vezes, por 
exemplo, se quiséssemos por um LED para piscar você deveria dizer se antes de 
começar o LED deve estar aceso ou apagado. 
Uma vez definido os parâmetros necessários para a execução do código 
chagamos á função void loop. Como o próprio nome já deixa evidente esta função 
se trata de uma estrutura de repetição, esta parte do código será executada 
continuamente até que algo a faça ser interrompida, ou o fornecimento de energia 
seja cortado. Dentro do loop deve estar tudo o que deve ser executado com seu 
Arduino, esta função irá ler os pinos analógicos e digitais definidos como entrada, 
enviar sinais para monitores, LED’s e atuadores em geral. 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
Figura 23: Esquema de estruturas básicas 
 
A maior parte do código fica concentrada na função void loop, uma vez que 
é nesta parte do programa que todas as atividades a serem executadas estarão 
reunidas, é nela ainda que os valores recebidos atualizam os dados das variáveis, 
equações são continuamente calculadas e re-calculadas, e respostas á esses dados 
recebidos e processados são encaminhadas aos determinados atuadores pelas 
estruturas de controle de fluxo. 
 
3.2- bibliotecas e funções básicas: 
(Esta sessão contém algumas partes modificadas da apostila: Arduino: Cartilha de 
programação em C. Autor: João Alexandre Silveira) 
 
 Principais Bibliotecas: 
Afinal o que são bibliotecas? Bibliotecas são pacotes com funções que 
ajudam bastante na utilização de determinados componentes ou aplicativos da 
plataforma Arduino. 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
Segundo o site oficial da plataforma Arduino: “O ambiente Arduino pode ser 
estendido através do uso de bibliotecas, assim como a maioria das plataformas de 
programação. As bibliotecas fornecem funcionalidade extra para uso em sketchs, por 
exemplo, trabalhar com hardware ou manipular dados” 
 Para usar uma biblioteca em seu sketch, vá até o menu sketch, escolha 
Importar biblioteca e então basta selecionar a biblioteca que deseja incluir. 
 Várias bibliotecas vêm instaladas com o IDE, mas você também pode fazer 
o download ou criar a sua própria biblioteca. 
 
Para este curso as principais bibliotecas a serem incluídas durante nossos projetos 
serão: 
1) LiquidCrystal - para controlar displays de cristais líquidos ( LCD’s ). 
2) Servo - para controle de servo motores. 
3) SoftwareSerial - para comunicação serial em qualquer pino digital. 
4) Stepper - para controle de motores de passo. 
5) Ultrasonic – para utilização do sensor ultrassônico. 
Observação: existem bibliotecas no Arduino responsáveis por toda a estrutura 
básica de programação e funções essenciais que não precisam ser incluídas 
manualmente, elas já estão automaticamente incluídas apesar de não se ver sua 
inicialização. 
Principais Funções: 
Nesta sessão serão esplanadas as apenas as funções básicas para utilização do 
Arduino e serão listadas funções das bibliotecas especiais apresentadas 
anteriormente, que serão posteriormente utilizadas durante os projetos. Algumas 
dessas funções serão explanadas durante os projetos, outras não serão utilizadas 
neste curso de nível básico. 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
 
Funções de tempo (Figura 25): 
 
Figura 25: Funções de tempo 
 
Funções destinadas á pinos analógicos (Figura 26): 
 
 
Figura 26: Funções destinadas á pinos analógicos. 
Funções destinadas á pinos digitais (Figura 27): 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 Figura 27: Funções destinadas á pinos digitais 
 
Funções destinadas a comunicação serial (Figura 29): 
 
Figura 28: Funções destinadas a comunicação serial. 
 
 
 
 
 
 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
 
Funções matemáticas (Figura 29): 
 
Figura 29: Funções matemáticas 
 
 
Funções de bibliotecas especiais: 
 
 
 
Figura 30: Funções da biblioteca para servo motor 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
 Figura 31: Funções da biblioteca para motor de passo 
 
 
Figura 32: Funções da biblioteca para visor de LCD 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
4- PROJETOS PARA O CURSO BÁSICO: 
 
(Os projetos a seguir foram integralmente retirados do livro: Arduino Básico, 
páginas 27 e 28. Autor: Michael McRoberts) 
 
4.1- Parte 1: LED’s 
 
Projeto 1: LED piscante 
 
 
Componentes necessários: 
 
 
 
 
 
Conectando os componentes: 
 
 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
 
 
Digite o código: 
 
// Projeto 1 - LED piscante 
int ledPin = 10; 
void setup() { 
pinMode(ledPin, OUTPUT); 
} 
void loop() { 
digitalWrite(ledPin, HIGH); 
delay(1000); 
digitalWrite(ledPin, LOW); 
delay(1000); 
} 
 
 
Projeto 2: Sinalizador de código Morse 
 
Para este projeto usaremos os mesmos componentes e montagem do projeto 1, 
modificaremos apenas o código. 
 
Digite o código: 
 
// Projeto 2: Sinalizador de código Morse 
int ledPin = 10;// LED conectado ao pino 10 
void setup() { 
pinMode(ledPin, OUTPUT);// define o pino como saída 
} 
void loop() { 
// 3 traços 
for (int x=0; x<3; x++) { 
digitalWrite(ledPin, HIGH); // acende o LED 
delay(150); // espera 150ms 
digitalWrite(ledPin, LOW); // apaga o LED 
delay(100); // espera 100ms 
} 
delay(100);// espera 100ms para marcar o intervalo entre as letras 
// 3 traços 
for (int x=0; x<3; x++) { 
digitalWrite(ledPin, HIGH); // acende o LED 
delay(400); // espera 400ms 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
digitalWrite(ledPin, LOW); // apaga o LED 
delay(100); // espera 100ms 
} 
delay(100);// espera 100ms para marcar o intervalo entre as letras 
// 3 pontos novamente 
for (int x=0; x<3; x++) { 
digitalWrite(ledPin, HIGH); // acende LED 
delay(150); // espera 150ms 
digitalWrite(ledPin, LOW); // apaga o LED 
delay(100); // espera 100ms 
} 
delay(5000);// espera 5 segundos antes de repetir o sinal de SOS 
} 
 
Projeto 3: Semáforo Simples 
 
Componentes necessários: 
 
 
 
Conectando os componentes: 
 
 
 Universidade Federal do Vale do São FranciscoDigite o código: 
 
// Projeto 3 – Semáforo 
int ledDelay = 5000; // espera entre as alterações 
int redPin = 10; 
int yellowPin = 9; 
int greenPin = 8; 
void setup() { 
pinMode(redPin, OUTPUT); 
pinMode(yellowPin, OUTPUT); 
pinMode(greenPin, OUTPUT); 
} 
void loop() { 
digitalWrite(redPin, HIGH); // acende a luz vermelha 
delay(ledDelay); // espera 5 segundos 
digitalWrite(redPin, LOW); // acende a luz vermelha 
digitalWrite(yellowPin, HIGH); // acende a luz amarela 
delay(1000); // espera 2 segundos 
digitalWrite(greenPin, HIGH); // acende a luz verde 
digitalWrite(yellowPin, LOW); // apaga a luz amarela 
delay(ledDelay); // espera 5 segundos 
digitalWrite(yellowPin, HIGH); // acende a luz amarela 
digitalWrite(greenPin, LOW); // apaga a luz verde 
delay(2000); // espera 2 segundos 
digitalWrite(yellowPin, LOW); // apaga a luz amarela 
// agora nosso loop se repete 
} 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
Projeto 4: Semáforo Interativo 
 
Componentes necessários: 
 
 
 
Conectando os componentes: 
 
 
 
 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
 
 
Digite o código: 
 
// Projeto 4 – Semáforo interativo 
int carRed = 12; // estabelece o semáforo para carros 
int carYellow = 11; 
int carGreen = 10; 
int pedRed = 9; // estabelece o semáforo para pedestres 
int pedGreen = 8; 
int button = 2; // pino do botão 
int crossTime = 5000; // tempo para que os pedestres atravessem 
unsigned long changeTime; // tempo desde que o botão foi pressionado 
void setup() { 
pinMode(carRed, OUTPUT); 
pinMode(carYellow, OUTPUT); 
pinMode(carGreen, OUTPUT); 
pinMode(pedRed, OUTPUT); 
pinMode(pedGreen, OUTPUT); 
pinMode(button, INPUT); // botão no pino 2 
digitalWrite(carGreen, HIGH); // acende a luz verde dos carros 
digitalWrite(pedRed, HIGH); // acende a luz verde dos pedestres 
} 
void loop() { 
int state = digitalRead(button); 
/* verifica se o botão foi pressionado e se transcorreram 5 segundos desde a última vez 
que isso ocorreu */ 
if (state == HIGH && (millis() - changeTime) > 5000) { 
changeLights();// Chama a função para alterar as luzes 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
} 
} 
 
void changeLights() { 
digitalWrite(carGreen, LOW); // apaga o verde 
digitalWrite(carYellow, HIGH); // acende o amarelo 
delay(2000); // espera 2 segundos 
digitalWrite(carYellow, LOW); // apaga o amarelo 
digitalWrite(carRed, HIGH); // acende o vermelho 
delay(1000); // espera 1 segundo, por segurança 
digitalWrite(pedRed, LOW); // apaga o vermelho dos pedestres 
digitalWrite(pedGreen, HIGH); // acende o verde dos pedestres 
delay(crossTime); // espera por um intervalo de tempo predefinido 
// pisca o verde dos pedestres 
for (int x=0; x<10; x++) { 
digitalWrite(pedGreen, HIGH); 
delay(250); 
digitalWrite(pedGreen, LOW); 
delay(250); 
} 
// acende o vermelho dos pedestres 
digitalWrite(pedRed, HIGH); 
delay(500); 
digitalWrite(carYellow, HIGH); // acende o amarelo 
digitalWrite(carRed, LOW); // apaga o vermelho 
delay(1000); 
digitalWrite(carGreen, HIGH); // acende o verde 
digitalWrite(carYellow, LOW); // apaga o amarelo 
// registra o tempo desde a última alteração no semáforo 
changeTime = millis(); 
// depois retorna para o loop principal do programa 
} 
 
 
Projeto 5: Efeito de iluminação sequencial 
 
 
Componentes necessários: 
 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
 
Conectando os componentes: 
 
 
 
Digite o código: 
// Projeto 5 – Efeito de iluminação sequencial com LEDs 
byte ledPin[] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; // cria um vetor para os pinos dos LEDs 
int ledDelay(65); // intervalo entre as alterações 
int direction = 1; 
int currentLED = 0; 
unsigned long changeTime; 
void setup() { 
for (int x=0; x<10; x++) { 
pinMode(ledPin[x], OUTPUT); 
} 
changeTime = millis(); 
} 
void loop() { 
// verifica-se se já transcorreram ledDelay ms desde a última alteração 
if ((millis() - changeTime) > ledDelay) { 
changeLED(); 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
changeTime = millis(); 
} 
} 
void changeLED() { 
for (int x=0; x<10; x++) { // apaga todos os LEDs 
digitalWrite(ledPin[x], LOW); 
} 
digitalWrite(ledPin[currentLED], HIGH); // acende o LED atual 
currentLED += direction; // incrementa de acordo com o valor de direction 
// altera a direção se tivermos atingido o fim 
if (currentLED == 9) {direction = -1;} 
if (currentLED == 0) {direction = 1;} 
} 
 
Projeto 6: iluminação sequencial controlada 
 
Componentes necessários: 
 
Conectando os componentes: 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 
 
Digite o código: 
byte ledPin[] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; // Cria um vetor para os pinos dos LEDs 
int ledDelay; // intervalo entre as alterações 
int direction = 1; 
int currentLED = 0; 
unsigned long changeTime; 
int potPin = 2; // seleciona o pino de entrada para o potenciômetro 
 
void setup() { 
 for (int x = 0; x < 10; x++) { 
 // define todos os pinos como saída 
 pinMode(ledPin[x], OUTPUT); 
 } 
 changeTime = millis(); 
} 
void loop() { 
 ledDelay = analogRead(potPin); 
 // lê o valor do potenciômetro 
 if ((millis() - changeTime) > ledDelay) { 
 // verifica se transcorreram ledDelay ms desde a última alteração 
 changeLED(); 
 
 Universidade Federal do Vale do São Francisco 
 
 
 
 changeTime = millis(); 
 } 
} 
void changeLED() { 
 for (int x = 0; x < 10; x++) { 
 // apaga todos os LEDs 
 digitalWrite(ledPin[x], LOW); 
 } 
 // acende o LED atual 
 digitalWrite(ledPin[currentLED], HIGH); 
 currentLED += direction; 
 // incrementa de acordo com o valor de direction 
 // altera a direção se tivermos atingido o fim 
 if (currentLED == 9) { 
 direction = -1; 
 } 
 if (currentLED == 0) { 
 direction = 1; 
 } 
}