Você está na página 1de 127

Arduino na Pratica

Prof. Johnny Dreher


E-mail:
cursos@desenvolvaeletronica.com.br
Skype: johnnydreher
Eletronica Digital
Sistema de Numeração
• 0 1 2 3 4 5 6 7 8 9  Decimal
• 2003  2000 + 000 + 00 + 3
• 2*103 + 0*102 + 0 *101 + 3* 100
• 0 e 1  Binario
• 0 1 2 3 4 5 6 7 8 9 A B C D E F Hexadecimal
Sistema de Numeração
• Sistema Decimal:
• O mais usado, o numero mais a direita é o
menos significativo, ou seja, o que vale
menos.
• Os numerais variam de 0-9
• Mais facil e natural de entender
Sistema de Numeração
• Sistema Hexadecimal:
• O mais usado para representar numeros na
programação de microcontroladores.
• Cada numero representa 1 nibble. 1
nibble=4bits
• Os numerais variam de 0-9 e A-F
• Mais facil de entender a grandeza de 1 byte,
que varia de 00-FF
Sistema de Numeração
• Sistema binario
• O mais usado para representar numeros na eletronica
digital
• Cada numero representa 1 estado
• Os numerais variam entre 0 e 1
• O numeral mais a esquerda é o mais significativo, ou seja,
uma mudança nele tem uma mudança muito grande no
valor. Já o numeral a direita é o menos significativo, pois
uma mudança nele representa uma pequena mudança no
valor.
• Mais facil de entender o estado de cada pino do
microcontrolador, ou de cada bit de controle que iremos
aprender mais tarde.
Relação entre os sistemas
Microcontroladores
Microcontroladores
• Um microcontrolador (também denominado MCU) é
um computador em um chip.
• Possuem um processador, memória e periféricos de
entrada/saída.
• É um microprocessador que pode ser programado para
funções específicas, em contraste com outros
microprocessadores de propósito geral (como os
utilizados nos PCs).
• Eles são embarcados no interior de algum outro
dispositivo (geralmente um produto comercializado)
para que possam controlar as funções ou ações do
produto.
Microcontroladores
• Unidade Central de Processamento (CPU).
• A unidade central de processamento é
composta por uma unidade lógica aritmética
(ULA), por uma unidade de controle e por
unidades de memória especiais conhecidas
por registradores.
Microcontroladores
• Memoria
• As memorias são divididas em basicamente 3:
• Flash: Memória não-volatil onde o programa
fica armazenado, de alta velocidade de acesso
• EEPROM: memória não-volatil onde
armazenamos dados que não podemos
perder. Baixa capacidade de escrita
• RAM – Memoria volatil para controle de
aquisição de dados, calculos, escrita, etc...
Microcontroladores
• Periféricos
• São circuitos dedicados, externos a CPU, que
realizam tarefas sem gastar processamento,
bastando serem configurados.
• Serial
• PWM
• Conversor AD
• Timer
• Contadores
Microcontroladores
• PORTs
• É a forma de organização dos pinos de
IO(entrada e saida) do microcontrolador.
• Em microcontroladores de 8 bits, um port
pode controlar até 8 pinos.
• É o responsavel por endereçar os pinos para a
CPU e controlar o fluxo como entrada ou
saida.
Microcontroladores
• Os pinos do microcontrolador são divididos
em múltiplas funções.
• Podem ser pinos de I/O(entrada ou saída)
• Podem atuar como pinos dos periféricos do
microcontrolador, para os módulos de PWM,
conversor Analógico/Digital, Serial.
Microcontroladores
• A função dos pinos é configurada através de
registradores específicos.
• Quando utilizados como I/O, temos que
configurar a direção do pino, podendo ser ora
entrada(I – Input) ou saída(O – Output).
• A configuração do pino também é dada por bits.
• Cada bit corresponde a direção do pino.
• Para configurar o bit correspondente como
entrada, utilizamos o valor 1. 1 = I = Input
• Para configurar o bit correspondente como saída,
utilizamos o valor 0. 0 = O = Output
Microcontroladores
• Registradores
• São as posições de memoria RAM que contem
as informações referentes aos modulos do
microcontrolador
• Cada PORT, periferico, etc, tem no minimo 1
registrador associado a ele
Linguagem de programação C
Linguagem C
• Iremos utilizar no nosso curso a plataforma
arduino
• Essa plataforma utiliza uma linguagem
chamada Wiring, que é basicamente uma
linguagem chamada C
• Portanto, antes de partirmos para o
microcontrolador Arduino, iremos aprender
um pouco dessa linguagem
Linguagem C
• O C é "Case Sensitive"
• Vamos começar o nosso curso ressaltando um
ponto de suma importância: o C é "Case
Sensitive", isto é, maiúsculas e minúsculas fazem
diferença. Se declararmos uma variável com o
nome soma ela será diferente de Soma, SOMA,
SoMa ou sOmA. Da mesma maneira, os
comandos do C if e for, por exemplo, só podem
ser escritos em minúsculas pois senão o
compilador não irá interpretá-los como sendo
comandos, mas sim como variáveis.
Linguagem C
• Forma geral das funções
• Apresentamos aqui a forma geral de uma
função:

• tipo_de_retorno nome_da_função (lista_de_argumentos)


• {
• código_da_função
• }
Linguagem C
Formato para leitura com Intervalo
Tipo bits
scanf Inicio Fim
char 8 %c -128 127
unsigned char 8 %c 0 255
signed char 8 %c -128 127
int 16 %i -32.768 32.767
unsigned int 16 %u 0 65.535
signed int 16 %i -32.768 32.767
short int 16 %hi -32.768 32.767
unsigned short int 16 %hu 0 65.535
signed short int 16 %hi -32.768 32.767

long int 32 %li -2.147.483.648 2.147.483.647

signed long int 32 %li -2.147.483.648 2.147.483.647

unsigned long int 32 %lu 0 4.294.967.295


float 32 %f 3,40E-38 3.4E+38
double 64 %lf 0,00E-01 1,7E+308
long double 80 %Lf 3,4E-4932 3,4E+4932
Linguagem C
• COMANDOS DE CONTROLE DE FLUXO
• Os comandos de controle de fluxo são aqueles
que permitem ao programador alterar a
sequência de execução do programa. Vamos
dar uma breve introdução a dois comandos de
controle de fluxo
Linguagem C
• Constantes de barra invertida
• O C utiliza, para nos facilitar a tarefa de programar, vários códigos
chamados códigos de barra invertida. Estes são caracteres que podem ser
usados como qualquer outro.
Código Significado
\b Retrocesso ("back")
\f Alimentação de formulário ("form feed")
\n Nova linha ("new line")
\t Tabulação horizontal ("tab")
\" Aspas
\' Apóstrofo
\0 Nulo (0 em decimal)
\\ Barra invertida
\v Tabulação vertical
\a Sinal sonoro ("beep")
\N Constante octal (N é o valor da constante)
\xN Constante hexadecimal (N é o valor da constante)
Linguagem C
• Operadores Aritméticos e de Atribuição
• Os operadores aritméticos são usados para desenvolver
operações matemáticas. A seguir apresentamos a lista dos
operadores aritméticos do C:
Operador Ação
+ Soma (inteira e ponto flutuante)
- Subtração ou Troca de sinal (inteira e ponto flutuante)
* Multiplicação (inteira e ponto flutuante)
/ Divisão (inteira e ponto flutuante)
% Resto de divisão (de inteiros)
++ Incremento (inteiro e ponto flutuante)
-- Decremento (inteiro e ponto flutuante)
Linguagem C
• Operadores Relacionais e Lógicos
• Os operadores relacionais do C realizam comparações entre
variáveis. São eles:
Operador Ação
> Maior do que
>= Maior ou igual a
< Menor do que
<= Menor ou igual a
== Igual a
!= Diferente de
Linguagem C
• Para fazer operações com valores lógicos (verdadeiro e falso)
temos os operadores lógicos:

Operador Ação

&& AND (E)

|| OR (OU)

! NOT (NÃO)
Linguagem C
• Tabela de Precedências do C
• Esta é a tabela de precedência dos operadores em C.
Maior precedência
() []
! ~ ++ -- . -(unário) (cast) *(unário)
&(unário) sizeof
*/%
+-
<< >>
<<= >>=
== !=
&
^
|
&&
||
Menor precedência
Linguagem C
• Modeladores (Casts)
• Um modelador é aplicado a uma expressão. Ele força a mesma a ser
de um tipoespecificado. Sua forma geral é:
• (tipo)expressão Um exemplo:
– #include <stdio.h>
– int main ()
– {
– int num;
– float f;
– num=10;
– f=(float)num/7;
– printf ("%f",f);
– return(0);
– }
Linguagem C
• Modeladores (Casts)
• Se não tivéssemos usado o modelador no exemplo anterior o
C faria uma divisão inteira entre 10 e 7. O resultado seria 1
(um) e este seria depois convertido para float mas continuaria
a ser 1.0. Com o modelador temos o resultado correto.
Linguagem C
• if
• O comando if representa uma tomada de decisão do tipo "SE isto
ENTÃO aquilo". A sua forma geral é:
• if (condição) declaração;
• A condição do comando if é uma expressão que será avaliada. Se o
resultado for zero a declaração não será executada. Se o resultado
for qualquer coisa diferente de zero a declaração será executada.
• A declaração pode ser um bloco de código ou apenas um comando.
• É interessante notar que, no caso da declaração ser um bloco de
código, não é necessário (e nem permitido) o uso do ; no final do
bloco. Isto é uma regra geral para blocos de código.
Linguagem C
• #include <stdio.h>
• int main ()
• {
• int num;
• printf ("Digite um numero: ");
• scanf ("%d",&num);
• if (num>10)
• printf ("\n\nO numero e maior que 10");
• if (num==10)
• {
• printf ("\n\nVoce acertou!\n");
• printf ("O numero e igual a 10.");
• }
• if (num<10)
• printf ("\n\nO numero e menor que 10");
• return (0);
• }
Linguagem C
• 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.
Linguagem C
• 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;
• }
Linguagem C
• #include <stdio.h>

• int main ()
• {
• int num;
• printf ("Digite um numero: ");
• scanf ("%d",&num);
• switch (num)
• {
• case 9:
• printf ("\n\nO numero e igual a 9.\n");
• break;
• case 10:
• printf ("\n\nO numero e igual a 10.\n");
• break;
• case 11:
• printf ("\n\nO numero e igual a 11.\n");
• break;
• default:
• printf ("\n\nO numero nao e nem 9 nem 10 nem 11.\n");
• }
• return(0);
• }
Linguagem C
• for
• loop (laço) 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;
• A declaração no comando for também pode ser um bloco ({ } )
e neste caso o ; é omitido. O melhor modo de se entender o
loop for é ver de que maneira ele funciona "pordentro". O
loop for é equivalente a se fazer o seguinte:
Linguagem C
• inicialização;
• if (condição)
• {
• declaração;
• incremento;
• "Volte para o comando if"
• }
• Podemos ver 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, o incremento e
volta a testar a condição. Ele fica repetindo estas operações até que
a condição seja falsa.
Linguagem C
• #include <stdio.h>
• int main ()
• {
– int count;
– for (count=1;count<=100;count=count+1)
• printf ("%d ",count);
– return(0);
• }
Linguagem C
• Outro exemplo interessante é mostrado a
seguir: o programa lê uma string e conta
quantos dos caracteres desta string são iguais
à letra 'c‘
Linguagem C
• #include <stdio.h>
• int main ()
• {
– char string[100]; /* String, ate' 99 caracteres */
– int i, cont;
– printf("\n\nDigite uma frase: ");
– gets(string); /* Le a string */
– printf("\n\nFrase digitada:\n%s", string);
– cont = 0;
– for (i=0; string[i] != '\0'; i=i+1)
– {
• if ( string[i] == 'c' ) /* Se for a letra 'c' */
• cont = cont +1; /* Incrementa o contador de caracteres */
– }
– printf("\nNumero de caracteres c = %d", cont);
– return(0);
• }
Linguagem C
• 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. Pode-se também omitir a
declaração e fazer um loop sem conteúdo.
Linguagem C
• Vamos ver um exemplo do uso do while. O programa abaixo é executado enquanto
i for menor que 100. Veja que ele seria implementado mais naturalmente com um
for
• #include <stdio.h>
• int main ()
• {
– int i = 0;
– while ( i < 100)
– {
• printf(" %d", i);
• i++;
– }
– return(0);
• }
Linguagem C
• O programa abaixo espera o usuário digitar a tecla 'q' e só depois finaliza:
• #include <stdio.h>
• int main ()
• {
– char Ch;
– Ch='\0';
– while (Ch!='q')
– {
• scanf("%c", &Ch);
– }
– return(0);
• }
Linguagem C
• break
• Nós já vimos dois usos para o comando break: interrompendo os comandos switch e for.
• Na verdade, estes são os dois usos do comando break: ele pode quebrar a execução de um
comando (como no caso do switch) ou interromper a execução de qualquer loop (como no
casodo for, do while ou do do while). O break faz com que a execução do programa continue
naprimeira linha seguinte ao loop ou bloco que está sendo interrompido.
• for(t=0; t<100; ++t)
• {
– count=1;
– for(;;)
– {
• printf("%d", count);
• count++;
• if(count==10) break;
– }
• }
Linguagem C - Exercicios

• Faça um algoritmo que receba 20 números, e


ao final informe quantos estava na faixa entre
5 e 15, (5 e 15 estão dentro da faixa) e
quantos eram divisíveis por 5.
Linguagem C - Exercicios

• Faça um algoritmo que some os números


compreendidos entre os valores 10e 100, e no
final imprima o valor total da soma
Linguagem C - Exercicios

• Faça um algoritmo que receba 10 numeros


entre 0 e 100. Caso o numero esteja fora da
faixa, deve pedir novamente até o numero
estar correto. Ao final avisar quantos números
informados são pares e quantos são divisíveis
por 3
Linguagem C
• Strings

• No C uma string é um vetor de caracteres


terminado com um caractere nulo. O caracter
nulo é um caractere com valor inteiro igual a zero
(código ASCII igual a 0). O terminador nulo
também pode ser escrito usando a convenção de
barra invertida do C como sendo '\0'. Para
declarar uma string, podemos usar o seguinte
formato geral:
• char nome_da_string[tamanho];
Linguagem C
• Isto declara um vetor de caracteres (uma string)
com número de posições igual a tamanho. Note
que, como temos que reservar um caractere para
ser o terminador nulo, temos que declarar o
comprimento da string como sendo, no mínimo,
um caractere maior que a maior string que
pretendemos armazenar. Vamos supor que
declaremos uma string de 7 posições e
coloquemos a palavra João nela. Teremos:

J o a o \0 ... ...
Linguagem C
• No caso anterior, as duas células não usadas têm
valores indeterminados. Isto acontece porque o C
não inicializa variáveis, cabendo ao programador
esta tarefa. Portanto as únicas células que são
inicializadas são as que contêm os caracteres 'J',
'o', 'a', 'o' e '\0‘ . Se quisermos ler uma string
fornecida pelo usuário podemos usar a função
gets(). Um exemplo do uso desta função é
apresentado abaixo. A função gets() coloca o
terminador nulo na string, quando você aperta a
tecla "Enter".
Linguagem C

• #include <stdio.h>
• int main ()
• {
– char string[100];
– printf ("Digite uma string: ");
– gets (string);
– printf ("\n\nVoce digitou %s",string);
– return(0);
• }
Linguagem C

• #include <stdio.h>
• int main ()
• {
– char string[100];
– printf ("Digite uma string: ");
– gets (string);
– printf ("\n\nVoce digitou %s",string);
– return(0);
• }
Linguagem C
• Neste programa, o tamanho máximo da string que você pode
entrar é uma string de 99 caracteres. Se você entrar com uma
string de comprimento maior, o programa irá aceitar, mas os
resultados podem ser desastrosos. Veremos porque
posteriormente. Como as strings são vetores de caracteres, para
se acessar um determinado caracter de uma string, basta
"indexarmos", ou seja, usarmos um índice para acessarmos o
caracter desejado dentro da string. Suponha uma string
chamada str. Podemos acessar a segunda letra de str da seguinte
forma:
• str[1] = 'a';
• Por quê se está acessando a segunda letra e não a primeira? Na
linguagem C, o índice começa em zero. Assim, a primeira letra da
string sempre estará na posição 0. A segunda letra sempre
estará na posição 1 e assim sucessivamente.
Linguagem C
• Segue um exemplo que imprimirá a segunda letra da
string "Joao“
• #include <stdio.h>
• int main()
• {
– char str[10] = "Joao";
– printf("\n\nString: %s", str);
– printf("\nSegunda letra: %c", str[1]);
– str[1] = 'U';
– printf("\nAgora a segunda letra eh: %c", str[1]);
– printf("\n\nString resultante: %s", str);
– return(0);
• }
Linguagem C
• Nesta string, o terminador nulo está na posição 4.
Das posições 0 a 4, sabemos que temos caracteres
válidos, e portanto podemos escrevê-los. Note a
forma como inicializamos a string str com os
caracteres 'J' 'o' 'a' 'o' e '\0' simplesmente declarando
char str[10] = "Joao". Veremos, posteriormente que
"Joao" (uma cadeia de caracteres entre aspas) é o
que chamamos de string constante, isto é, uma
cadeia de caracteres que está pré-carregada com
valores que não podem ser modificados. Já a string
str é uma string variável, pois podemos modificar o
que nela está armazenado, como de fato fizemos.
Arduino
Arduino
• Arduino é uma plataforma de prototipagem eletrônica
de hardware livre, projetada com um microcontrolador
Atmel AVR de placa única, com suporte de
entrada/saída embutido, uma linguagem de
programação padrão, a qual tem origem em Wiring, e é
essencialmente C/C++.
• O objetivo do projeto é criar ferramentas que são
acessíveis, com baixo custo, flexíveis e fáceis de se usar
por artistas e amadores. Principalmente para aqueles
que não teriam alcance aos controladores mais
sofisticados e de ferramentas mais complicadas.
Arduino – Hardware
• Sua placa consiste em um microcontrolador
Atmel AVR de 8 bits, com componentes
complementares para facilitar a programação e
incorporação para outros circuitos. Um
importante aspecto é a maneira padrão que os
conectores são expostos, permitindo o CPU ser
interligado a outros módulos expansivos,
conhecidos como shields. Os Arduinos originais
utilizam a série de chips megaAVR, especialmente
os ATmega8, ATmega168, ATmega328 e a
ATmega1280; porém muitos outros
processadores foram utilizados por clones deles.
Arduino – Hardware
Arduino – Hardware
Arduino – Software
• O Arduino IDE é uma aplicação multiplataforma escrita
em Java derivada dos projetos Processing e Wiring. É
esquematizado para introduzir a programação a
pessoas não familiarizadas com o desenvolvimento de
software.
• Inclui um editor de código com recursos de realce de
sintaxe, parênteses correspondentes e identação
automática, sendo capaz de compilar e carregar
programas para a placa com um único clique.
• Com isso não há a necessidade de editar Makefiles ou
rodar programas em ambientes de linha de comando.
Arduino – Software
• Tendo uma biblioteca chamada "Wiring", ele
possui a capacidade de programar em C/C++.
• Isto permite criar com facilidade muitas
operações de entrada e saída, tendo que
definir apenas duas funções no pedido para
fazer um programa funcional
Arduino – Software
• Estrutura
• setup() – é a parte inicial do codigo onde
todos os pinos e perifericos são inicializados e
configurados
• loop() – é a parte do codigo que será
executada “eternamente”, onde os controles
são feitos e toda a logica é aplicada
Arduino – Software
• Constantes
• HIGH | LOW – Niveis dos pinos dos
microcontrolador
• INPUT | OUTPUT | INPUT_PULLUP –
Configuração dos pinos para entrada ou saida
• true | false – Constante para testar verdadeiro
ou falso
Arduino – Software
• Funções digitais
• pinMode() – configura os pinos como entrada ou saida.
Sintaxe: pinMode(pin, mode);
Exemplo: pinMode(13,OUTPUT);
• digitalWrite() – Escreve um valor digital nos pinos do
microcontrolador.
Sintaxe: digitalWrite(pin, value)
Exemplo: digitalWrite(13, HIGH);
• digitalRead() – Le o estado de um pino. Retorna HIGH para
nivel alto e LOW para nivel baixo.
Sintaxe: digitalRead(pin);
Exemplo: digitalRead(13);
Arduino – Software
• Funções de tempo
• millis() – Retorna o numero de milissegundos
desde que o microcontrolador foi inicializado
• micros() – Retorna o numero de
microssegundos desde que o microcontrolar
foi inicializado
• delay() – faz um delay em milissegundos
• delayMicroseconds() – faz um delay de
microssegundos
Arduino – Software
• Funções de tempo
• millis() – Retorna o numero de milissegundos
desde que o microcontrolador foi inicializado
• micros() – Retorna o numero de
microssegundos desde que o microcontrolar
foi inicializado
• delay() – faz um delay em milissegundos
• delayMicroseconds() – faz um delay de
microssegundos
Arduino – Software
• Definições de pinos
• Podemos definir os pinos através de
constantes ou pela diretiva #define.
• Const int pinLed=13 ou
• #define pinLed 13
• Na pratica ambos tem o mesmo efeito.
Arduino – Software
• Habitualmente, o primeiro programa que é executado tem a
simples função de piscar um LED. No ambiente de
desenvolvimento, o usuário escreve um programa exemplo
como este
Arduino – Exercicios
• Fazer o LED do arduino piscar 1x por
segundo(meio segundo aceso, meio apagado)
• Fazer o led do Arduino piscar 1x por
segundo(200 ms aceso, 800ms apagado)
• Fazer o Led do arduino piscar 4x por segundo
• Fazer o led piscar 3 vezes rapidas(200ms
aceso, 200ms apagado) e aguardar 1 segundo
para voltar a piscar
Arduino – Exercicios
• Fazer um codigo com 2 leds, onde o primeiro
acende, fica 200ms aceso, o segundo acende,
fica 200ms aceso, e os dois apagam juntos por
1 segundo
Arduino – Exercicios
• Fazer um codigo com 2 leds novamente.
• O led1(pino 13) deve piscar 3x(500ms aceso,
500ms apagado). Após isso o led2(pinos 12)
deve acender.
• Após isso, o led1 deve repetir o processo
anterior de piscadas, e apos o led2 deve
apagar
Arduino – Exercicios
• Ligar um botão no pino 2 do arduino.
• Configurar o pino com o modo INPUT_PULLUP
• Faça um codigo que enquanto o botão estiver
pressionado, o led1(pino 13) deve acender e o
led2(pino 12) deve apagar.
• Se o botão estiver solto, os leds devem trocar
de estado.
Arduino – Variaveis
• Variaveis são espaços da memoria RAM que
são reservados para armazenar valores que
utilizamos.
• As variaveis podem armazenar valores do tipo
inteiro, ponto-flutuante, caracteres ou
binarios.
Arduino – Variaveis
• Iremos iniciar as variaveis inteiras.
• Elas podem ser curtas(int) ou longas(long)
• Podemos executar todas operações
matematicas com elas, alem de
incremento(++) ou decremento(--)
Arduino – Variaveis
• Exemplo:
• Fazer um codigo que a cada 5 pulsos no botão,
acende o led por 5 segundos
Arduino – Exercicios
• Chave 1 – Pino 2
• Led – Pino 13
• Fazer um programa que apertando a chave
faça o Led piscar a 1 hz, e apertando
novamente faça o led parar de piscar
Arduino – Exercicios
• Led1 – Pino 13
• Led2 – Pino 12
• Led3 – Pino 11
• Led4 – Pino 10
• Fazer um programa que pisque o led1 a 0,5hz,
o led2 a 1hz, o led3 a 2hz e o led 4 a 4hz
Delay sem parar
• Normalmente, quando precisamos monitorar algo ou mudar o
estado de algum periferico com um tempo, utilizamos um
delay.
• Porem como delay temos um problema, que é deixar o
processador parado para gastar o tempo
• No arduino não é diferente, porem existem tecnicas para
evitar isso.
• Se queremos um delay de 1 segundo, normalmente
utilizariamos o seguinte comando: delay(1000);
• Porem, com a função millis() podemos trabalhar de outra
forma
Delay sem parar
• Long tempoInicial;
• Void loop()
• {
– if(millis()-tempoInicial>500)
– {
• digitalWrite(led, !digitalRead(led));
• tempoInicial=millis();
– }
– ....
• }
Delay sem parar
• No codigo anterior fizemos um led piscar com uma frequencia
de 1hz, porem enquanto o mesmo piscava pudemos testar
chaves, ou outros perifericos
• Essa tecnica é util, pois não ficamos travados numa rotina de
delay, permitindo assim sermos “multi-tarefas”
Exercicios
• Led1 – Pino D13
• Led2 – Pino D12
• Chave1 – Pino D2
• Chave2 – Pino D3
• Ler a chave1, se a mesma ficar pressionada por mais de
200ms, fazer o led1 piscar a 1hz.
• Ler a chave2, se a mesma ficar pressionada por mais de
200ms, fazer o led2 piscar a 5hz.
– if(millis()-tempoInicial>500)
– {
• digitalWrite(led, !digitalRead(led));
• tempoInicial=millis();
– }
Porta Serial
• A porta serial é uma das formas de comunicação presentes no
arduino mais faceis de serem utilizadas para testar valores.
Com ela é possivel enviar mensagens para o computador pela
USB e ler as mesmas no monitor serial.
• Alem disso, a porta serial tambem pode ser utilizada para
receber mensagens do computador no microcontrolador.
• Porem, estes não são os unicos usos. A porta serial é utilizada
para as mais diversas comunicações, porem no nosso curso
vamos nos focar no seu uso para auxiliar o desenvolvimento.
Porta Serial
• Serial.begin(velocidade) – Comando utilizado para iniciar a
porta serial. A velocidade pode variar, desde 300bps até
115200 bps.
• Serial.print(valor) – Exibe os dados na serial de forma possivel
de ser lida.
• Serial.print(78) Imprime "78"
• Serial.print(1.23456) imprime "1.23"
• Serial.print('N') imprime "N"
• Serial.print("Hello world.") imprime "Hello world."
Porta Serial
• Podemos tambem exiber numeros em diversos formatos:
• Serial.print(78, BIN) Imprime "1001110"
• Serial.print(78, OCT) Imprime "116"
• Serial.print(78, DEC) Imprime "78"
• Serial.print(78, HEX) Imprime "4E"
• Serial.print(1.23456, 0) Imprime "1"
• Serial.print(1.23456, 2) Imprime "1.23"
• Serial.println(1.23456, 4) Imprime "1.2346"
• Serial.println(valor) – Identico ao anterior, porem esse
comando tambem inclui uma quebra de linha, para iniciar
uma nova linha de texto no monitor serial
Contadores - Exercicios
• Led1 – Pino 13
• Led2 – Pino 12
• Botao1 – pino 2
• Botao2 – pino 3
• Faça um codigo que incremente um Contador de 0 a 10 com o
botao1 e decremente com o botao2.
• Quando o contador estiver em 0, o led1 deve permanecer
aceso, e quando o contador estiver em 10, o led2 deve
permanecer aceso.
• Sempre que o contador mudar de valor deve avisar no
monitor da serial o novo valor. Alem disso sempre que chegar
a 0 ou 10 deve avisar que chegou ao valor minimo ou maximo.
Leitura Analogica
• No mundo real, nem sempre as leituras podem ser feitas em
uma logica binaria.
• Em algumas situações temos que ler sensores que variam os
valores, como por exemplo: Temperatura, pressão,
iluminação, etc.
• Para isso, os microcontroladores, e o Arduino, possuem
maneiras de transformar essas leituras em um valor que
possa ser trabalhado.
• Na leitura analogica, ao inves de termos apenas 1 ou 0 temos
os valores variando de 0 a 1023, sendo que 0 = 0V e 1023 =
5V.
• Com isso, temos que 255 = 1,25V, 512 = 2,5V, 768 = 3,75V.
Leitura Analogica
• Os comandos de leitura analogica são bem parecidos com os
de leituras binarias.
• Valor = analogRead(A1);
• Com isso podemos ler um valor que varia entre 0 e 1023.
Leitura Analogica - Exercicios

• Faça um codigo que ligue o led1 quando a leitura for maior


que 250, o led2 quando for maior que 500, o led3 quando for
maior que 750 e o led4 quando for maior que 1000.
• Os leds devem apagar quando a tensão baixar
Leitura Analogica - Exercicios

• Faça um codigo que faça a leitura do sensor LDR e indique


pela serial se o sensor tem luz ou não.
• Comece simulando pela serial os valores que o Arduino le no
LDR com e sem luz
Leitura Analogica - Exercicios

• Faça um codigo que ative o ventilador quando a temperatura


for maior que 32ºC
• Comece simulando pela serial os valores que o Arduino le no
sensor de temperatura
Escrita Analogica
• Assim como a leitura analogica, o Arduino tem a possibilidade
de fazer escritas pseudo-analogicas.
• As escritas são pseudo-analogicas porque não são exatamente
analogicas, mas sim são PWMs, onde o resultado é que uma
tensão media se forma na saida.
• Para a escrita analogica, utilizados um comando semelhante
ao digital, o analogWrite(pin, Valor)
• O pin pode ser qualquer pino digital marcado com o ~ na
frente.
• São os pinos 3, 5, 6, 9, 10 e 11
• O valor pode variar de 0 a 255
Escrita Analogica
• PWM:
Escrita Analogica
• Como podemos ver, a tensão varia de 0 a 5V repetidas vezes
por segundo.
• Com isso, o efeito que temos na maioria dos elementos(luzes,
motores, etc) é que temos uma tensão analogica da media.
• Se utilizarmos o valor 127, por exemplo, passamos metade do
tempo fornecendo tensão ao elemento, e metade do tempo
sem nada. Com isso, a tensão media fica em 2,5V, ou seja,
metade. Se utilizarmos um sistema para acionar elementos de
12V, teriamos 6V, e assim por diante.
Escrita Analogica
• Curiosidade: Um LED normal precisa de aproximadamente 2V para
acender. Como no PWM estamos fornecendo 0 e 5V, mesmo que a
tensão media sobre o LED seja menor, por exemplo 1V,
continuamos com o led aceso, porem com pouco brilho.
• Outro comando muito util para leituras e escritas analogicas
tambem é o comando map
• Variavel = map(variavel, InicialMenor, inicialMaior,
FinalMenor,FinalMaior)
• Essa função faz uma regra de 3, transformando por exemplo um
valor que varia de 0-1023 para um valor de 0 a 255.
• Isso é util quando queremos usar um valor lido de uma entrada
analogica para uma saida analogica.
Escrita Analogica: Exemplo
Escrita Analogica: Exercicios
Utilizando a entrada analogica A0 e a saida 11, faça um circuito
que conforme a luz diminua no LDR, o brilho do LED aumente.
Display de 7 segmentos
• O display de 7 segmentos é um dos dispositivos mais baratos e simples de
se acionar.
• Trata-se de um arranjo de 7 ou 8 LEDs(ponto decimal) que bastam ser
acionados.
• Os displays se dividem em anodo comum e catodo comum
• No Anodo comum todos os lados positivos dos leds são ligados juntos e
acionamos os outros segmentos colocando 0V
• No catodo comum todos os lados negativos dos leds são ligados juntos e
acionamentos os outros segmentos colocando alguma tensão.
Display de 7 segmentos
Display de 7 segmentos
Display de 7 segmentos
Display de 7 segmentos - Exercicio
• Faça um contador de 0 a 9,
exibindo os valores no display
de 7 segmentos.
• Utilize a entrada 2 e 3 como
botoes de incremento e
decremento
• Utilize as saidas 4, 5, 6, 7, 8, 9
e 10 para acionar os
segmentos.
Display de 7 segmentos - Exercicio
• Faça um controle para o ventilador usando o PWM e um potenciometro
• Exiba no display de 7 segmentos o valor proporcional de 0 a 9, sendo 0
com o ventilador parado e 9 com o ponto decimal acional quando estiver
em 100%
LCD
• O display de LCD é a forma mais simples de exibir dados em um
equipamento.
• Pela ordem natural, displays LCDs eram preteridos antigamente pelo seu
custo. Hoje, contando itens como consumo de I/O, consumo de energia, e
valor, os displays LCDs já apresentam grande vantagem perto de outras
opções, como displays de 7 segmentos para exibição de dados complexos
LCD
• Os displays que iremos utilizar são os mais comuns do mercado, os
displays 2x16, baseados no controlador HD44780 ou semelhantes
• Esse display trabalha com comunicação paralela, sendo possivel utilizar 8
linhas de dados ou somente 4 linhas de dados
• Alem dos dados, obrigatoriamente precisamos de 2 pinos para o controle:
– Enable – Um pulso alto nesse pino determinar ao controlador que leia os dados
presentes no barramento
– Register Select – Esse pino determina se iremos enviar um comando ou uma informação
ao LCD
• Alternativamente, temos tambem a opção do pino Read/Write, que
possibilita ler os dados que estão no LCD. Por conveniencia, iremos apenas
escrever no LCD, portanto esse pino deverá sempre estar ligado ao
0V(ground).
• Ainda, temos os pinos de alimentação, de controle de contraste e do
backlight(quando disponivel)
LCD
• Pinagem padrão de um LCD 2x16
LCD
• O arduino possui uma biblioteca muito bem formada para trabalhar com o LCD
• Para utilizar o LCD, precisamos defini-lo como um componente no nosso
codigo, logo nas primeiras linhas precisamos cria-lo e apontar os pinos dele.
• Podemos fazer isso de 4 formas:
– LiquidCrystal(rs, enable, d4, d5, d6, d7)
– LiquidCrystal(rs, rw, enable, d4, d5, d6, d7)
– LiquidCrystal(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7)
– LiquidCrystal(rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7)
• Sendo:
– rs: O numero do pino do arduino que conectamos pino RS
– rw: O numero do pino do arduino que conectamos pino RW(opcional)
– enable: O numero do pino do arduino que conectamos pino Enable
– d0, d1, d2, d3, d4, d5, d6, d7: Os numeros dos pinos do Arduino que conectamos ao
barramento de dados, sendo que d0, d1, d2 e d3 são opcionais
• Exemplo de ligação do LCD ao Arduino
• LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
LCD
• Alem disso, logo no setup(), precisamos obrigatoriamente iniciar o LCD,
através do comando begin.
• Neste comando definimos quantas colunas e quantas linhas que o display
conectado possui
• lcd.begin(Colunas, Linhas)
• Para o nosso caso
• lcd.begin(16,2);

• OBS: Cuidado pois existem alguns displays maiores(4 linhas) que utilizam 2
controladores, e nesse caso temos que trata-los como 2 displays
separados.
LCD
• Outros comandos:
• clear() – Limpa o display
• home() – posiciona o cursor na primeira linha e primeiro caracter
• setCursor(col, lin) – Posiciona o cursor para escrita na coluna e linha
desejada. Ambos iniciam com o 0(linha zero e coluna 0)
• write(data) – Escreve apenas um caracter no LCD
• print(data) – Escreve diversos caracteres no LCD
• cursor() – Ativa o cursor do LCD(sublinha)
• noCursor() – Desativa o cursor
• blink() – Faz o cursor ficar piscando
• noBlink() – Desativa o cursor piscando
• display() – Ativa o display para exibição de dados
• noDisplay() – Apaga a tela do display
LCD
• Exemplo:
• #include <LiquidCrystal.h>
• LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
• void setup()
• {
– lcd.begin(16,2);
– lcd.print("hello, world!");
• }
• void loop() {}
Exercicio
• LCD – RS – Pino 12
• E – Pino 11
• DB4 – Pino 5
• DB5 – Pino 4
• DB6 – Pino 3
• DB7 – Pino 2
• Potenciometro – A0
• Fazer no LCD um Voltimetro, exibindo a leitura da tensão lida
no potenciometro
Serial - Recebimento
• Já vimos a Serial do arduino enviando dados para o PC
• Hoje veremos como funciona a comunicação no sentido
inverso, com o Arduino recebendo os dados do PC
• Para isso utilizaremos as funções:
• Serial.available() – Retorna quantos caracteres estão
disponiveis na serial para leitura
• Serial.read() – Retorna o caracter mais antigo na fila.
• Serial. readString() – Le uma linha inteira de dados
• Serial. readStringUntil(terminator) – Le uma sequencia de
caracteres até receber um caracter que termine a linha
Serial - Recebimento
• Para trabalhar com a serial iremos utilizar um novo
tipo de variaveis, que são as Strings
• Strings são variavies que acumulam diversos
caracteres. Por isso quando são criadas precisamos
definir um tamanho para elas.
• Exemplo:
• String inputString = "“;
• Dentro do setup precisamos definir o tamanho:
• inputString.reserve(200); - Aqui reservamos 200
posições da memoria
Strings
• Para as strings tambem temos as funções de
conversão:
• toInt() – Converte para inteiro
• toFloat() – Converte para um valor com ponto
Exercicio
• Ligue o LCD com o mesmo esquema da ultima
aula, e exiba no LCD os dados que chegam
pela serial.
• Controle para que a cada 16 bytes recebidos,
o LCD troque a linha
Teclado Matricial
• É um arranjo de chaves em matrizes para otimizar o
numero de pinos necessários.
• Cada interceção da matrix é preenchida com uma
chave.
• O funcionamento é bem simples. Colocamos todas as
linhas em nivel alto, e apenas a linha que queremos
ler colocamos em nivel baixo.
• Ao fazer isso fazemos a leitura dos pinos das colunas.
Se uma das chaves estiver pressionada, teremos o
nivel 0.
Teclado Matricial
Teclado Matricial
• Deste modo temos 16 botoes, mas utilizamos
apenas 8 pinos.
• O numero pode ser ajustado conforme
necessidade. Podemos ter 25 botões com
apenas 10 pinos(5 linhas e 5 colunas) e assim
por diante
Teclado Matricial
• O arduino possui uma biblioteca bem
completa chamada keypad.
Interrupções
• Interrupções são eventos de alta prioridade que
ocorrem no microcontrolador
• Alguem lembra quando era necessário configurar o
IRQ do mouse no Windows?
• Elas podem ocorrer de diversas fontes como: Serial,
timers, Externas
• Quando ocorre uma interrupção o codigo para de ser
executado na sua sequencia normal e passa a
trabalhar no tratamento da interrupção
Interrupções
• Interrupção Externa: Ela existe em 2 pinos do
Arduino, o digital 2 e digital 3.
• Digital 2 é a interrupção externa 0 e Digital 3 é
interrupção externa 1
• Podemos configurar esses pinos para que sempre
que ocorra uma mudança no estado do pino o
programa salte para outra parte do codigo
Interrupções
• attachInterrupt(digitalPinToInterrupt(pin), ISR, mode);
• Pin – Numero do pino que queremos utilizar – 2 ou 3
• ISR – Função que será chamada quando ocorrer a interrupção
• Mode – Modo com que ocorre a interrupção:
– LOW - atua quando o pino esta em nivel baixo
– CHANGE atua sempre que ocorre uma mudança
– RISING atua sempre que o pino muda de estado baixo para alto(borda de
subida)
– FALLING atua sempre que o pino muda de estado alto para baixo(borda de
descida)
Interrupções
• int pin = 2;
• volatile int state = LOW;

• void setup() {
• pinMode(pin, OUTPUT);
• attachInterrupt(digitalPinToInterrupt(pin), blink, CHANGE);
• }

• void loop() {
• digitalWrite(pin, state);
• }

• void blink() {
• state = !state;
• }
Interrupções
• Importante 1: A função que trata a interrupção
precisa ser muito pequena. Devido ao fato de que o
programa para a execução e tambem ao fato de que
as interrupções pode ocorrer diversas vezes
seguidas.
• Importante 2: Precisa ser feito um controle para que
os ruidos das chaves não causem diversas
interrupções. E por isso tambem não pode ser
utilizado um delay dentro da interrupção para
filtragem

Você também pode gostar