0 notas0% acharam este documento útil (0 voto) 252 visualizações34 páginasProgramação C++ Arduino
Tutorial Programação Arduino em C++
Direitos autorais
© © All Rights Reserved
Levamos muito a sério os direitos de conteúdo. Se você suspeita que este conteúdo é seu,
reivindique-o aqui.
Formatos disponíveis
Baixe no formato PDF ou leia on-line no Scribd
Ci circuitar (../../index.html)
Programagao para Arduino -
Primeiros Passos
Conceitos iniciais de programagao para Arduino
Autor: Luis Fernando Chavier
Neste tutorial vamos apresentar os conceitos basicos de
programacao necessdrios para comegar a utilizar o Arduino, e
também outros tipos de de sistemas embarcados semelhantes. Para
conhecer o que é possivel construir com esses sistemas, veja amais sobre Arduino e sistemas embarcados, explore a nossa segao
de tutoriais (../index.html).
Se vocé esta usando o Arduino pela primeira vez, nao deixe de ver
nossos tutoriais de como configurar o Arduino para Windows
(../configurando-o-arduino-no-windows/index.html) ou Mac
(../configurando-o-arduino-no-mac/index.htm!).
Aqui nos vamos explicar os conceitos de programagao desde o inicio,
e vocé nao precisa saber nada sobre Arduino ou programagao de
computadores para comegar. Se vocé ja tem experiéncia prévia com
programagao, este tutorial talvez nao acrescente muito ao seu
conhecimento.
Nos vamos aprender como funciona um programa simples, fazendo
nele algumas modificagdes ao longo do tutorial. Se vocé tiver acesso
a um Arduino, vocé pode usa-lo ao longo do tutorial para praticar os
conceitos aprendidos, tornando a experiéncia muito mais legal. Vocé
s6 precisa de um Arduino, original ou compativel, e mais nada. Entao
vamos Ia.
Este tutorial é dividido nas seguintes partes:
¢ Introdugao
« Computador
« Programa de Computador
« Algoritmo (Programa)
° Varidvel
© Tipo de Dado
° Atribuicao
¢ Operador
« Fungao
o Chamada de Fungao
o Valor de Retorno* Comentarios
Estruturas de Controle
° While
© For
° if
o IfElse
¢ Bibliotecas
* Concluséo
a I|ntrodugao
O objetivo deste tutorial é apresentar, de uma forma simples e rapida,
0 basico de programagao para que vocé possa comegar a utilizar o
Arduino em seus projetos, sem ter que ler muitos livros ou artigos
sobre programacado. O tema "desenvolvimento de software" como um
todo é muito abrangente, entaéo vamos focar apenas nos conceitos
que sao importantes para Arduino e sistemas embarcados em geral.
Existem muitas outras coisas para se aprender na parte de software
que nao vamos abordar aqui. No final do artigo nds colocamos links
que vocé pode seguir para aprender conceitos mais avangados ou
conceitos de software que nao sAo muito utilizados na programacgao
de sistemas embarcados.
Vamos comegar explicando como funciona um computador (lembre-
se que 0 Arduino é, no fundo, um computador).
~« Computador
Um computador é, de forma simplificada, uma maquina que
processa instrugdes. Essas instrug6es sao processadas no "cérebro"
do computador, que se chama microprocessador. Todo computador
possui pelo menos um microprocessador. O Arduino, por exemplo,nada mais é do que um computador muito pequeno, e ele utiliza um
microprocessador do modelo ATmega. Alguns microprocessadores,
como o ATmega, também sao chamados de microcontroladores.
« Programa de Computador
Um programa de computador, ou software, 6 uma sequéncia de
instrugses que sao enviadas para o computador. Cada tipo de
microprocessador (cérebro) entende um conjunto de instrugdes
diferente, ou seja, o seu proprio "idioma". Também chamamos esse
idioma de linguagem de maquina.
As linguagens de maquina sao, no fundo, as Unicas linguagens que
os computadores conseguem entender, so que elas sao muito dificeis
para os seres humanos entenderem. E por isso nods usamos uma
coisa chamada linguagem de programagao.
No caso de sistemas como o Arduino (os chamados sistemas
embarcados), o software que roda no microprocessador é também
chamado de firmware.
a Linguagem de Programagao
Nos seres humanos precisamos converter as nossas idéias para uma
forma que os computadores consigam processar, ou seja, a
linguagem de maquina. Os computadores de hoje (ainda) nao
conseguem entender a linguagem natural que nds usamos no dia a
dia, entao precisamos de um outro "idioma" especial para instruir o
computador a fazer as tarefas que desejamos. Esse "idioma" é€ uma
linguagem de programagado, e na verdade existem muitas delas
(http://en.wikipedia.org/wiki/List_of_programming_languages).
Essas linguagens de programagao também sao chamadas de
linguagens de programagdo de alto nivel. A linguagem de
programagao utilizada no Arduino é& a linguagem C++(http://en.wikipedia.org/wiki/C++) (com pequenas modificagées), que é
uma linguagem muito tradicional e conhecida. Essa é a linguagem
que utilizaremos ao longo deste tutorial.
Para converter um programa escrito em uma linguagem de alto nivel
para linguagem de maquina, nés utilizamos uma coisa chamada
compilador. A agao de converter um programa para linguagem de
maquina € chamada compilar. Para compilar um programa,
normalmente se utiliza um ambiente de desenvolvimento (ou IDE,
do inglés Integrated Development Environment), que € um aplicativo
de computador que possui um compilador integrado, onde vocé pode
escrever 0 seu programa e compila-lo. No caso do Arduino, esse
ambiente de desenvolvimento é o Arduino IDE.
O texto contendo o programa em uma linguagem de programagao de
alto nivel também é conhecido como 0 cédigo fonte do programa.
a Algoritmo (Programa)
Um algoritmo, ou simplesmente programa, é uma forma de dizer
para um computador o que ele deve fazer, de uma forma que nés
humanos conseguimos entender facilmente. Os algoritmos
normalmente sao escritos em linguagens de programacao de alto
nivel. Isso se aplica a praticamente qualquer computador, inclusive o
Arduino, onde um algoritmo também é conhecido como sketch. Para
simplificar, a partir de agora nds vamos nos referir aos algoritmos,
programas ou sketches simplesmente como "programas".
Um programa € composto de uma sequéncia de comandos,
normalmente escritos em um arquivo de texto. Para este tutorial,
vamos usar como base os comandos do programa mais simples do
Arduino, 0 Blink, que simplesmente acende e apaga um LED, e
vamos destrincha-lo ao longo do tutorial. Veja abaixo o cédigo fonte
do Blink:int led = 13;
void setup() {
pinMode(led, OUTPUT);
void loop() {
digitalWrite(led, HIGH);
delay (1000) ;
digitalWrite(led, LOW);
delay (1000) ;
a Variavel
Uma variavel 6 um recurso utizado para armazenar dados em um
programa de computador. Todo computador possui algum tipo de
memoria, e uma varidvel representa uma regido da memoria usada
para armazenar uma determinada informagao. Essa informagao pode
ser, por exemplo, um numero, um caractere ou uma sequéncia de
texto. Para podermos usar uma variavel em um programa Arduino,
nos precisamos fazer uma declaragao de variavel, como por
exemplo:
int led;
Nesse caso estamos declarando uma variavel do tipo int chamada
led . Em seguida nos falaremos mais sobre o tipo de dado de uma
variavel.
“a Tipo de DadoO tipo de dado de uma variavel significa, como o prdprio nome diz, o
tipo de informagao que se pode armazenar naquela variavel. Em
muitas linguagens de programacao, como C++, é obrigatdrio definir o
tipo de dado no momento da declaragao da variavel, como vimos na
declaragao da variavel led acima. No caso dos mddulos Arduino que
usam processador ATmega, os tipos mais comuns de dados que
utilizamos sao:
* boolean : valor verdadeiro ( true ) ou falso ( false )
¢ char : um caractere
¢ byte : um byte, ou sequéncia de 8 bits
* int : numero inteiro de 16 bits com sinal (-32768 a 32767)
© unsigned int : numero inteiro de 16 bits sem sinal (0 a 65535)
© long : numero inteiro de 16 bits com sinal (-2147483648 a
2147483647)
© unsigned long : numero inteiro de 16 bits sem sinal (0a
4294967295)
© float : numero real de precisao simples (ponto flutuante)
© double : numero real de precisao dupla (ponto flutuante)
© string : sequéncia de caracteres
© void : tipo vazio (nado tem tipo)
Para conhecer todos os tipos de dado suportados pelo Arduino, veja a
segao "Data Types" nessa pagina
(http://arduino.cc/en/Reference/HomePage).
A Atribuigao
Atribuir um valor a uma variavel significa armazenar o valor nela para
usar posteriormente. O comando de atribuigao em C++ 60 =. Para
atribuirmos o valor 13 a variavel led que criamos acima, fazemos
assim:
led = 13;Quando se armazena um valor em uma varidvel logo na sua
inicializagao, chamamos isso de inicializagdo de variavel. Assim, no
nosso programa de exemplo temos:
int led = 13;
O objetivo dessa linha de cédigo é dizer que o pino 13 do Arduino
sera utilizado para acender o LED, e armazenar essa informagao para
usar depois ao longo do programa.
Os valores fixos usados no programa, como o valor 13 acima, sao
chamados de constantes, pois, diferentemente das variaveis, 0 seu
valor néo muda.
~« Operador
Um operador é um conjunto de um ou mais caracteres que serve
para operar sobre uma ou mais variaveis ou constantes. Um exemplo
muito simples de operador é 0 operador de adigao, o +. Digamos
que queremos somar dois numeros e atribuir a uma variavel x . Para
isso, fazemos o seguinte:
x= 243;
Apos executar 0 comando acima, a variavel x ira contero valor 5 .
Cada linguagem de programagao possui um conjunto de operadores
diferente. Alguns dos operadores mais comuns na linguagem C++
sao:
¢ Operadores aritméticos:
° +: adigao ("mais")
o - : subtragao ("menos")o *:multiplicagdo ("vezes")
© /: divisao (“dividido por")
¢ Operadores ldgicos:
© 8& : conjunc¢ao ("e")
|| : disjungao ("ou")
: igualdade ("igual a")
!= : desigualdade ("diferente de")
! : negagao ("nao")
> : "maior que"
menor que"
"maior ou igual a"
: "menor ou igual a"
« Operadores de atribuigao:
o =: atribui um valor a uma variavel, como vimos acima.
0 00 0
oo 0
°o <=
Ao longo do desenvolvimento dos seus projetos, aos poucos vocé se
familiarizara com todos esses operadores. Para uma lista completa,
veja essa pagina
(http://pt.wikipedia.org/wiki/Operadores_em_C_e_C++) da Wikipedia.
a Fungao
Uma fungao é, em linhas gerais, uma sequéncia de comandos que
pode ser reutilizada varias vezes ao longo de um programa. Para criar
uma fungao e dizer o que ela faz, nds precisamos fazer uma
declaragao de fungao. Veja como uma fungao é declarada no nosso
programa de exemplo:
void setup() {
pinMode(led, OUTPUT);
tAqui estamos declarando uma fungao com 0 nome setup() . O que
ela faz é executar os comandos de uma outra fungao pinMode() . A
agdo de executar os comandos de fungao previamente declarada é
denominada chamada de fung&o. Nos nao precisamos declarar a
fungado pinMode() porque ela ja é declarada automaticamente no caso
do Arduino.
« Chamada de Fungao
Chamar uma fungao significa executar os comandos que foram
definidos na sua declaragado. Uma vez declarada, uma fungdo pode
ser chamada varias vezes no mesmo programa para que seus
comandos sejam executados novamente. Para chamarmos a nossa
fungao setup() , por exemplo, nds usariamos o seguinte comando:
setup();
No entanto, no caso do Arduino, nds nao precisamos chamar a
fungdo setup() , porque ela é chamada automaticamente. Quando
compilamos um programa no Arduino IDE, ele chama a fungao
setup() uma vez e depois chama a fungao loop() repetidamente até
que o Arduino seja desligado ou reiniciado.
a Valor de Retorno
A palavra chave que vem antes do nome da fungao na declaragao
define o tipo do valor de retorno da funcgao. Toda vez que uma
fungao é chamada, ela é executada e devolve ou retorna um
determinado valor - esse é o valor de retorno, ou simplesmente
retorno da fungao. O valor de retorno precisa ter um tipo, que pode
ser qualquer um dos tipos de dados citados anteriormente. No caso
da nossa fungao setup() , 0 tipo de retorno € void, o que significa
que a fungao nao retorna nada.Para exemplificar, vamos criar uma fungao que retorna alguma coisa,
por exemplo um numero inteiro. Para retornar um valor, nés
utilizamos 0 comando return :
int #() {
return 1;
Quando chamada, a fungao £() acima retorna sempre o valor 1.
Vocé pode usar o valor de retorno de uma fungao para atribui-lo a
uma variavel. Por exemplo:
x= #05
Apos declarar a fungao +£() e chamar 0 comando de atribuicado
acima, a variavel x ira contero valor 1.
«a Parametros
Um outro recurso importante de uma fun¢do sao os parametros. Eles
servem para enviar algum dado para a fungao quando ela é chamada.
Vamos criar por exemplo uma fungdo que soma dois numeros:
int soma(int a, int b) {
return a + b;
Aqui acabamos definir uma fungao chamada_ soma() , que aceita dois
numeros inteiros como parametros. Nos precisamos dar um nome
para esses parametros, e nesse caso escolhemos a e b. Esses
parametros funcionam como variavel que vocé pode usar dentro dafungdo. Sempre que chamarmos a fungao soma() , precisamos
fornecer esses dois ntimeros. O comando return a + 6;
simplesmente retorna a fungaéo com a soma dos dois numeros.
Vamos entdo somar 2 + 3 e atribuir o resultado para uma variavel x :
x = soma(2, 3);
Apos a chamada acima, a variavel x ira contero valor 5 .
a Comentarios
Um comentario é um trecho de texto no seu programa que serve
apenas para explicar (documentar) o cédigo, sem executar nenhum
tipo de comando no programa. Muitas vezes, os comentarios sao
usados também para desabilitar comandos no cdédigo. Nesse caso,
dizemos que o cddigo foi comentado.
Na linguagem C++, um comentario pode ser escrito de duas formas:
« Comentario de linha: inicia-se com os caracteres // , tornando
todo o resto da linha atual um comentario.
« Comentario de bloco: inicia-se com os caracteres /* e termina
com os caracteres */ . Todo o texto entre o inicio e o término se
torna um comentario, podendo ser composto de varias linhas.
Para facilitar a visualizagado, os ambientes de desenvolvimento
geralmente mostram os comentarios em uma cor diferente. No caso
do Arduino IDE, por exemplo, os comentarios sao exibidos na cor
cinza. Vamos entao explicar o que o programa de exemplo faz,
inserindo nele varios comentarios explicativos:/*
Programa¢do para Arduino - Primeiros Passos
Programa de exemplo: Blink
ot]
/*
Declara¢ado da variavel "led"
Indica que o LED esta conectado no pino digital 13 do Arduin
o (D13).
*/
int led = 13;
/*
Declaracdo da funcdo setup()
Esta fun¢gdo é chamada apenas uma vez, quando o Arduino é ligad
0 ou reiniciado.
*/
void setup() {
// Chama a funcao pinMode() que configura um pino como entra
da ou saida
pinMode(led, OUTPUT); // Configura o pino do LED como saida
/*
Declaracao da fun¢cao loop()
Apds a funcdo setup() ser chamada, a func&o loop() é chamada r
epetidamente até
o Arduino ser desligado.
*/
void loop() {
// Todas as linhas a seguir sdo chamadas de fun¢do com passa
gem de parametros
// As fungées sao executadas em sequéncia para fazer o LED a
cender e apagardigitalWrite(led, HIGH); // Atribui nivel ldgico alto ao pin
o do LED, acendendo-o
delay (10@@) ; // Espera 10@@ milissegundos (um se
gundo)
digitalwrite(led, LOW); // Atribui nivel ldgico baixo ao pi
no do LED, apagando-o
delay (10@0) ; // Espera 100@ milissegundos (um se
gundo)
// Apés terminar a funcdo loop(), ela é executada novamente
repetidas vezes,
// @ assim o LED continua piscando.
a Estruturas de Controle
Estruturas de controle sao blocos de instrugées que alteram o fluxo
de execugao do cddigo de um programa. Com elas é possivel fazer
coisas como executar comandos diferentes de acordo com uma
condigao ou repetir uma série de comandos varias vezes, por
exemplo.
A seguir nés veremos algumas das estruturas de controle mais
comuns usadas nas linguagens de programagao em geral. Vamos
também modificar 0 nosso programa de teste para exemplificar
melhor como essas estruturas funcionam.
a While
O while é uma estrutura que executa um conjunto de comandos
repetidas vezes enquanto uma determinada condigdo for verdadeira.
While em inglés quer dizer "enquanto", e pronuncia-se "udi-ou". Ele
segue o seguinte formato:while(condi¢&o) {
Vamos entao fazer uma modificagdo no nosso programa para
exemplificar melhor como 0 while funciona. O nosso objetivo agora é
fazer o LED piscar trés vezes, depois esperar cinco segundos, piscar
mais trés vezes e assim por diante. Nos vamos mudar o contetdo da
fungdo loop() para o seguinte:
// Nariavel para contar o numero de vezes que o LED piscou
int i = @;
// Pisca o LED trés vezes
while(i < 3) {
digitalwrite(led, HIGH);
ino do LED, acendendo-o
delay(1000) ;
segundo)
digitalwrite(led, LOW);
pino do LED, apagando-o
delay(1000) ;
segundo)
i-si+41;
o LED piscou
,
delay (5000) ;
o LED de novo
// Atribui nivel légico alto ao p
// Espera 1000 milissegundos (um
// Atribui nivel légico baixo ao
// Espera 100@ milissegundos (um
// Aumenta o numero de vezes que
// Espera 5 segundos para piscarPrimeiro nés declaramos uma variavel i. Essa varidvel vai contar
quantas vezes o LED ja piscou desde o inicio do programa ou desde
a Ultima pausa de cinco segundos. Nos vamos inicializar essa variavel
com zero porque no inicio da fungao loop() o LED ainda nao piscou
nenhuma vez sob essas condigées.
Em seguida nos inserimos 0 comando while , que deve ser seguido
de uma condigao definida entre parénteses. Enquanto essa condi¢ao
for verdadeira, todo o bloco de comandos entre os caracteres { e }
é executado repetidamente. No caso do nosso programa, enquanto o
numero de "piscadas" do LED (representado pela varidvel i) for
menor do que trés, nés continuamos a executar os comandos que
fazem o LED piscar. Isso é representado pela expressdo i < 3
dentro dos parénteses.
Entre os caracteres { e } nds colocamos o cédigo que faz o LED
piscar, como anteriormente, mas nao podemos nos esquecer de
somar 1 a variavel que conta o numero de "piscadas". Isso é feito na
seguinte linha de cédigo:
izsi+1; // Aumenta o numero de vezes que
© LED piscou
Veja que apds executar todos os comandos entre { e }, sempre
teremos na varidvel i o numero de vezes que o LED piscou desde o
inicio da fungao loop() . Vamos percorrer a sequéncia de passos
executada cada vez que a fungdo loop() é chamada:
1. Atribuimos @ a variavel i: o LED ainda nao piscou nenhuma
vez.
2. Comparamos se i < 3: como @ €menordo que 3,
executamos os comandos entre { e }:
1. Executamos os comandos para acender e apagar o LED.2. Somamos 1 a variavel i , tornando-a 1 : sabemos que 0
LED piscou uma vez.
3. Voltamos ao inicio do while € comparamos se i < 3: como 1
é menor do que 3, executamos os comandos entre { e }
novamente:
1. Executamos os comandos para acender e apagar o LED.
2. Somamos 1 a variavel i , tornando-a 2 : sabemos que 0
LED piscou duas vezes.
4. Voltamos ao inicio do while e comparamos se i < 3:como 2
é menor do que 3, executamos os comandos entre { e }
novamente:
1. Executamos os comandos para acender e apagar o LED.
2. Somamos 1 a variavel i , tornando-a 3 : sabemos que 0
LED piscou trés vezes.
5. Voltamos ao inicio do while e comparamos se i < 3: como 3
nao é menor do que 3 , nado executamos mais os comandos
entre { e€ } e prosseguimos a proxima instrucdo.
6. Esperamos cinco segundos por meio da chamada delay(5ee@) .
Apos esses passos, chegamos ao final da fungao loop() , e como ja
sabemos, ela é chamada novamente pelo sistema do Arduino. Isso
reinicia o ciclo, executando os passos acima indefinidamente.
Rode o programa modificado com as instrugdes acima no seu Arduino
e tente variar o numero de "piscadas" e o numero
a For
Agora que nds ja aprendemos o comando while, fica muito facil
aprender 0 comando for, pois ele 6 quase a mesma coisa. Vamos
modificar 0 contetido da fungao loop() como fizemos acima, porém
usando o for no lugar do while :// Variavel para contar o nimero de vezes que o LED piscou
int i;
// Pisca o LED trés vezes
for(i = @; i < 3; i++) {
digitalwrite(led, HIGH); // Atribui nivel ldgico alto ao p
ino do LED, acendendo-o
delay(10@@) ; // Espera 10@@ milissegundos (um
segundo)
digitalwrite(led, LOW); // Atribui nivel légico baixo ao
pino do LED, apagando-o
delay(10@@) ; // Espera 10@@ milissegundos (um
segundo)
t
delay(5000) ; // Espera 5 segundos para piscar
o LED de novo
A primeira modificagao que fizemos foi declarar a variavel i sem
inicializa-la com o valor @. Nos podemos fazer isso porque o
comando for fara isso para a gente. Ele segue o seguinte formato:
for(inicializacao; condi¢io; finalizacao) {
Vamos descrever cada item separadamente:
¢ Condigdo: é uma expressao verificada repetidamente, de forma
idéntica a condigdo entre parénteses do while . Enquanto ela for
verdadeira, os comandos entre { e } continuam sendo
executados.lizagao: 6 um comando executado apenas uma vez no
inicio do comando for .
¢ Finalizagao: é um comando executado repetidas vezes ao final
de cada execugdo dos comandos entre { e }.
Podemos entao verificar que o for nada mais é do que um while
acrescido de um comando de inicializagéo e um comando de
finalizagado. Para o nosso programa de teste, esses comandos sao,
respectivamente:
* i=: inicializa a contagem do numero de "piscadas".
* i++: soma 1 avariavel i ao final da execugao dos comandos
entre { e }; nesse caso ele é equivalente ao comando
i=i+41.Ooperador ++ & chamado de operador de
incremento, e é muito usado na linguagem C++.
Se executarmos o programa acima no Arduino, veremos que o
resultado € o mesmo que obtivemos com o programa que fizamos
anteriormente utilizando 0 while .
a if
O if é uma das estruturas mais basicas de programagao em geral. /f
significa "se" em inglés, e 6 exatamente isso que ele faz: ele verifica
uma expressdo e, apenas se ela for verdadeira, executa um conjunto
de comandos. Em linguagem natural, ele executa uma ldgica do tipo:
"se isso for verdadeiro, entao faga aquilo"
Para ilustrar, vamos modificar o nosso programa de exemplo para que
ele faga a mesma coisa que fizemos com 0 while e o for acima, porém
vamos fazer isso usando um if , que segue o seguinte formato:
if(condigao) {A ldgica é muito simples: sempre que a condi¢ao vor verdadeira, os
comandos entre { e } sao executados, caso contrario o programa
prossegue sem executa-los. Vamos ver entao como fica a fungao
loop() :
// Nariavel para contar o numero de vezes que o LED piscou
int i = @;
void loop() {
digitalWrite(led, HIGH); // Atribui nivel légico alto ao pin
o do LED, acendendo-o
delay (1028) ; // Espera 100@ milissegundos (um se
gundo)
digitalWrite(led, LOW); // Atribui nivel légico baixo ao pi
no do LED, apagando-o
delay (1020) ; // Espera 1000 milissegundos (um se
gundo)
itt; // Incrementa o nimero de “piscada
s"
if(i == 3) {
delay (50@@) ; // Espera 5 segundos para piscar o
LED de novo
i-=0; // Reinicia o contador de ntmero de
“piscadas"
t
Aqui a ldgica € um pouco diferente: nds vamos manter a funcao
loop() piscando o LED como no programa original, porém vamos
inserir uma espera adicional de 5 segundos apds cada 3 piscadas.
Para isso, criamos uma variavel i fora da fungao loop(); ela
precisa ser declarada de fora da fungdo para poder reter o seu valorentre cada execugao da fungao loop() . Chamamos isso de variavel
global. Quando a variavel é declarada dentro do corpo da fungao, ela
nao retém o valor etnre cada execugao, sendo reiniciada a cada vez
que a funcao é re-executada. Chamamos isso de variavel local.
Nos usaremos entao essa variavel global i para contar, novamente,
o numero de vezes que o LED acendeu e apagou. Na declaracado da
variavel, nds a inicializamos com o valor @ para indicar que o LED
nao acendeu nenhuma vez ainda. A fungao loop() entaéo comega a
ser executada, acendendo e apagando o LED. Para contar o numero
de vezes que o LED piscou, nds adicionamos a seguinte linha de
cdédigo:
itt; // Incrementa o numero de “piscada
s
Em seguida utilizamos 0 if para verificar se acabamos de acender o
LED pela terceira vez. Para isso, usamos a expressao i == 3 na
condigao do if . Se essa expressdo for verdadeira, isso que dizer
que o LED ja acendeu 3 vezes, entao inserimos uma pausa adicional
de 5 segundos com a chamada delay(seee) e reiniciamos a
contagem do numero de "piscadas" novamente com o seguinte
comando:
i=; // Reinicia o contador de numero de
“piscadas"
A partir dai a fungao 1oop() continua sendo chamada e o ciclo se
inicia novamente.
A If-ElseO if-else, também conhecido como if-then-else, pode ser visto como
uma extensao do comando if. Else em inglés significa "caso
contrario", e ele faz exatamente o que o nome diz: "se isso for
verdadeiro, entao faga aquilo, caso contrario, faga outra coisa". Ele
segue 0 seguinte formato:
if(condic¢ao) {
} else {
Para exemplificar, vamos usar 0 programa do for que mostramos
acima, mas vamos dessa vez fazer o LED acender e apagar quatro
vezes antes de dar uma pausa de cinco segundos. Depois vamos
fazer com que na terceira de cada uma dessas quatro "piscadas", o
LED acenda por um periodo mais curto. Dentro da fungao 1loop() ,
teremos o seguinte:// Variavel para contar o nimero de vezes que o LED piscou
int i;
// Pisca o LED trés vezes
for(i = @; i < 3; i++) {
if(i == 2) {
digitalWrite(led, HIGH); // Atribui nivel légico alto ao
pino do LED, acendendo-o
delay(2@0) ; // Espera 20@ milissegundos (um
segundo)
digitalwrite(led, LOW); // Atribui nivel légico baixo a
© pino do LED, apagando-o
delay (180@) ; // Espera 1800 milissegundos (u
m segundo)
} else {
digitalWrite(led, HIGH); // Atribui nivel ldgico alto ao
pino do LED, acendendo-o
delay(10@@) ; // Espera 100@ milissegundos (u
m segundo)
digitalWrite(led, LOW); // Atribui nivel ldgico baixo a
o pino do LED, apagando-o
delay (1@0@) ; // Espera 10@@ milissegundos (u
m segundo)
t
}
delay(500@) ; // Espera 5 segundos para piscar
o LED de novo
Aqui o que fazemos é, toda vez que vamos acender o LED, verificar
se é a terceira vez que isso acontece, por meio do comando if com
acondigaéo i == 2. Se essa expresso for verdadeira, isso quer dizer
que ja acendemos o LED duas vezes e estamos prestes a acendé-lopela terceira vez; nesse caso mudamos o tempo que o LED fica
acaso para um valor menor, de 0,2 segundo (uma redugao de 0,8
segundo) e o tempo que ele fica apagado para um valor maior, de 1,8
segundos (aumento de 0,8 segundo).
Mas e se essa nao for a terceira vez que o LED esta sendo acionado?
E ai que entrao else: se a condicdo do if for verdadeira, o bloco
de comandos entre { e } logo apds o if &€ executado, caso
contrario, 0 bloco entre { e } apdso else é executado. Isso quer
dizer que para a primeira, segunda e quarta "piscadas" sera usado 0
tempo padrao de um segundo.
a Bibliotecas
As coisas que aprendemos nas segées anteriores sao importantes
para implementar a ldgica do seu programa no Arduino, mas
normalmente vocé vai querer fazer mais coisas além de apenas
acender um LED. Quando se faz tarefas mais complexas ou se utiliza
algum outro circuito conectado ao seu Arduino, um recurso muito
importante sdo as bibliotecas.
Uma biblioteca € basicamente composta de cédigo fonte adicional
que vocé adiciona ao seu projeto por meio do comando include.
Vejamos como adicionar, por exemplo, uma biblioteca para controle
de um display de cristal liquido (LCD):
#include
Uma biblioteca do Arduino se apresenta normalmente como uma ou
mais classes que possuem fungdes, os métodos, para acionar
dispositivos, configura-los ou executar alguma_ outra_ tarefa.
Continuando com o exemplo do display de cristal liquido, para usa-lono seu programa, primeiro é preciso inicializa-lo. O que fazemos
nesse caso é criar um objeto para acessar o LCD (tecnicamente isso
se chama instanciar um objeto). Vejamos como isso é feito:
LiquidCrystal 1cd(12, 11, 5, 4, 3, 2);
Quando fazemos isso, lcd se torma um objeto da classe
Liquidcrystal . Isso € o equivalente a criar uma variavel do tipo
Liquidcrystal . Os parametros que sao passados entre parénteses
servem para inicializar a configuragdo desse objeto, e nesse caso
correspondem aos numeros dos pinos que foram utilizados para
conectar o LCD ao Arduino.
Quase sempre as bibliotecas de Arduino possuem um método
begin() , que serve para fazer a configuragao inicial do dispositivo
que esta sendo controlado. Para chamar a fungao begin() do objeto
lcd que criamos, fazemos o seguinte:
1cd.begin(16, 2);
Normalmente esse método begin() & chamado de dentro da fun¢ao
setup() , ou Seja, durante a inicializagdo do programa. Os parametros
do método begin(), nesse caso, correspondem ao numero de
colunas e o numero de linhas do LCD, respectivamente.
Feitos esses passos, j4 podemos escrever texto no LCD. Fazemos
isso usando o método print() do objeto icd, sempre que
precisarmos ao longo do programa:
1cd.print("Oi!");O método print() @ apenas um dos varios métodos disponiveis na
biblioteca Liquidcrystal . Para saber todos os métodos fornecidos por
uma determinada biblioteca, é preciso consultar a documentagado
fornecida com ela.
Este é o processo basico de utilizagao de bibliotecas no Arduino. Para
mais informagées, leia a documentagao fornecida com a biblioteca
que vocé esta usando.
Classes, objetos e métodos sao conceitos de programagao
orientada a objetos. Nao vamos explicar tudo em detalhes aqui, mas
se vocé quiser aprender mais sobre isso, siga os links relacionados
no final da pagina.
a Conclusao
Neste tutorial nds vimos os conceitos basicos de programagéo
necessarios para programar um Arduino ou mesmo outras
plataformas de hardware embarcado. Mas isso € so o comego, e
ainda ha muitas coisas a se aprender, tanto na parte de hardware
quanto na parte de software. Segue entao uma lista para outros
artigos e tutoriais interessantes para que vocé possa aprender
conceitos mais avangados e expandir as suas possibilidades:
« Programagao em C
© Instalando o ambiente de desenvolvimento
(http://www. inf.pucrs.br/flash/cbp/instala_devc/) (PUC-RS)
(http:/Awww.inf.pucrs.br/~pinho/Laprol/IntroC/IntroC.htm),
(PUC-RS)
o Curso de Programacao em C
(http:/Awww2.dec.ufmg.br/disciplinas/pc/source/introducao_c
(Unicamp)
o C Programming (http:/Awww2. its.strath.ac.uk/courses/c/)
(em inglés)
« Programagao orientada a objetos em C++o C++ como uma linguagem de programagao orientada a
objetos
(http:/Awww.ic.unicamp.br/~cmrubira/aacesta/cpp/cpp15.htm
(Unicamp)
o Entendendo C++ (http://www.arnaut.eti.br/op/cppai00.htm) -
versao original em inglés aqui
(http://web. ift.uib.no/~ladi/KURS/OTHER/CPL/cplus0.html).
e Escrevendo bibliotecas para o Arduino
(http://arduino.cc/en/Hacking/LibraryTutorial) (em inglés)
ADC v1.0
(../../nanoshields/modulos/adc10/index.html)Alevino
(../../nanoshields/modulos/alevino/index.html)
Base Board
(../../nanoshields/modulos/base-board/index.html)Ethernet v1.0
(../../nanoshields/modulos/ethernet10/index.html)
LCD v1.0
(../../nanoshields/modulos/Icd10/index.html)MicroSD
(../../nanoshields/modulos/microsd/index.html)
Mosfet
(../../nanoshields/modulos/mosfet/index.html)Relay
(../../nanoshields/modulos/relay/index.html)
RTCMem
(../../nanoshields/modulos/rtcmem/index.html)Thermocouple
(../../nanoshields/modulos/thermocouple/index. html)
Triac
(../../nanoshields/modulos/triac/index.html)USB 1.0
(../../nanoshields/modulos/usb10/index.html)
Zero Cross
(../../nanoshields/modulos/zero-cross/index.html)Assine a nossa lista de e-mails e fique por dentro das
novidades da Circuitar!
Seu email: Assinar
f
(https://www.facebook.com/circuitar.com.br)
v
(https://twitter.com/circuitar)
st
(https://plus.google.com/+CircuitarBr)
0
(https://github.com/circuitar)
Copyright © 2018 Circuitar Eletrénicos
Circuitar Eletrénicos LTDA