Escola de engenharia de lorena



Baixar 1.06 Mb.
Pdf preview
Página1/5
Encontro21.07.2020
Tamanho1.06 Mb.
  1   2   3   4   5

UNIVERSIDADE DE SÃO PAULO 

ESCOLA DE ENGENHARIA DE LORENA 

 

TUTORIAL 



Experimentos e conceitos de programação computacional usando o 

microcontrolador ARDUINO 

 

 



 

SUMÁRIO 

 

Conteúdo 



Pág. 

Projeto 1: LED pisca pisca 

Projeto 2: Código Morse 



Projeto 3: Semáforo 

Projeto 4: Semáforo interativo 



10 

Projeto 5: Perseguição de LEDs 

12 

Projeto 6: Efeito interativo de perseguição de LEDs 



16 

Projeto 7: Lâmpada pulsante 

20 

Projeto 8: Lâmpada de humor 



22 

Projeto 9: Efeito fogo de LED 

21 

Projeto 10: LEDs controlados 



28 

Projeto 11: Acionando um motor CC 

35 

Projeto 12: Atuador piezelétrico 



38 

Projeto 13: Sensor de temperatura com o CI LM35 

31 

 

 



 

 

 



 

 

 



 

 

 



 

 

 



 

 

 



Prof. Carlos Yujiro Shigue 

 

 



Lorena, SP 

2014 

 

Projeto 1 - LED Pisca-Pisca 

 

Neste  projeto  vamos  configurar  e  programar  o 



Arduino  para  fazer  um  LED  piscar.  Vamos  usar 

LED  vermelho  para  ensinar  alguns  conceitos  de 

eletrônica  e  de  codificação  em  C  ao  longo  do 

caminho. 

 

Componentes 

 

 



 

Montagem 

Primeiro,  certifique-se  que  o  seu  Arduino  está 

desligado.  Você  pode  fazer  isso  desconectando  o 

cabo  USB  ou  tirando  o  jumper  alimentador  do 

Arduino.  Em  seguida,  faça  as  ligações  desta 

maneira: 

 

 

 



Não importa se você usa diferentes fios coloridos 

ou  se  usa  orifícios  diferentes  sobre  a  protoboard

mas  necessáriamente  os  componentes  e  os  fios 

têm  de  serem  ligados  da  mesma  forma  que  o 

mostrado  na  Figura  acima.  Tenha  cuidado  ao 

inserir  os  componentes  na  protoboard.  Se  a 



protoboard for  nova,  o  ajuste  nos  furos fará  com 

que  a  inserção  dos  componentes  seja  um  pouco 

mais dura. Deixar de inserir os componentes com 

cuidado  pode  resultar  em  danos.  Verifique  se  o 

seu LED está ligado da maneira certa com a perna 

mais  comprida  conectada  ao  pino  digital  10.  A 

perna longa do LED é o anodo (+) e deve sempre 

ir para a alimentação de +5 V (neste caso, que sai 

do  pino  digital  10)  e  a  perna  mais  curta  é  o 

catodo (-)  e  deve  ir  para  o  pino  terra  (GND). 

Quando você estiver certo de que tudo está ligado 

corretamente,  conecte  o  Arduino  ao  computador 

pelo cabo USB. 

A seguir, abra o IDE Arduino e digite o seguinte 

código: 

 

// Projeto 1 - LED Pisca-Pisca 



int 

ledPin = 10; 

void setup

() { 


pinMode

(ledPin, 

OUTPUT

); 


void loop

() { 

digitalWrite



(ledPin, 

HIGH


); 

delay


(1000); 

digitalWrite

(ledPin, 

LOW


); 

delay


(1000); 

 



Agora pressione o Verificar / Compilar, botão no 

topo da IDE, para se certificar de que não há erros 

em  seu  código.  Se  esta  for  bem  sucedida,  agora 

você  pode  clicar  no  botão  Upload  para  enviar  o 

código  para  o  Arduino.  Se  você  tiver  feito  tudo 

certo,  você  deve  ver  agora  o  LED  vermelho  na 



protoboard piscar e desligar a cada 1 segundo. 

Agora  vamos  dar  uma  olhada  no  código  e  no 



hardware e descobrir como ambos trabalham. 

 

Descrição do código 

 

// Projeto 1 - LED Pisca-Pìsca 



int 

ledPin = 10; 

void setup

() { 


pinMode

(ledPin, 

OUTPUT

); 


void loop

() { 

digitalWrite



(ledPin, 

HIGH


); 

delay


(1000); 

digitalWrite

(ledPin, 

LOW


); 

delay


(1000); 

 



Então vamos dar uma olhada no código para este 

projeto, nossa primeira linha é: 

 

// Projeto 1 - LED Pisca-Pisca 



 

Isto é simplesmente um comentário no seu código 

e é ignorado pelo compilador (a parte do IDE que 

transforma o seu código em instruções do Arduino 

pode  compreender  antes  de  carregá-lo).  Qualquer 


 

texto  inserido  por  trás  de  um  comando  //  será 



ignorado  pelo  compilador  e  simplesmente  está  lá 

para  você,  ou  qualquer  outra  pessoa  que  lê  seus 

códigos.  Comentários  são  essenciais  em  seu 

código  para  lhe  ajudar  a  entender  o  que  está 

acontecendo  e  como  funciona  o  seu  código.  Os 

comentários também podem ser colocados após os 

comandos  como  na  próxima  linha  do  programa. 

Mais  tarde,  como  os  projetos  se  tornam  mais 

complexos  e  seu  código  expande-se  em  centenas 

ou talvez milhares de linhas, os comentários serão 

vitais  para  torná-lo  fácil  para  você  ver  como  ele 

funciona.  Você  pode  vir  até  com  um  espantoso 

pedaço de código, mas se você voltar e olhar esses 

códigos dias, semanas ou meses depois, você pode 

esquecer  como  tudo  funciona.  Os  comentários 

irão ajudá-lo a compreendê-lo facilmente. 

 

Além  disso,  se  seu  código  é  feito  para  ser  visto 



por  outras  pessoas  e  como  todo  o  ethos  do 

Arduino,  é  de  fato  fonte  aberta  à  comunidade, 

esperamos  que  quando  você  começar  a  fazer  seu 

próprio  material  com  o  Arduino,  você  esteja 

disposto  a  compartilhá-lo  com  o  mundo  em 

seguida,  comentários  permitirão  que  as  outras 

pessoas  entendam  o  que  está  acontecendo  no  seu 

código.  Você  também  pode  colocar  comentários 

em uma instrução usando em bloco comandos   / * 

e * /. 


Por exemplo, /* Todo o texto dentro da barra e os 

asteriscos  é  um  comentário  e  será  ignorado  pelo 

compilador * / A IDE irá ligar automaticamente a 

cor de qualquer texto comentado com cinza. 

A próxima linha do programa é: 

 

int 



ledPin = 10; 

 

Isto  é  conhecido  como  uma  variável.  Uma 



variável  é  um  local  para  armazenar  dados.  Neste 

caso, você está configurando uma variável do tipo 



int ou inteiro. Um inteiro é um número na faixa de 

- 32.768 a + 32.767. 

 Em  seguida,  você  atribuiu  o  nome  inteiro  de 

ledPin  e  deram-lhe  um  valor  de  10.  Nós  não 

temos  que  chamá-lo  de  ledPin,  poderíamos  tê-lo 

chamado  de  qualquer  coisa  que  quisessemos. 

Mas,  como  queremos  que  o  nosso  nome  da 

variável  seja  descritivo  o  chamamos  de  ledPin 

para  mostrar  que  o  uso  desta  variável  é  para 

definir quais os pinos no Arduino vamos usar para 

se  conectar  ao  nosso  LED.  Neste  caso,  estamos 

usando o pino digital 10. 

No  final  desta  declaração,  é  um  ponto  e  vírgula. 

Este  é  um  símbolo  para  dizer  ao  compilador  que 

esta  declaração  está  completa.  Apesar  de 

podermos chamar as nossas variáveis do jeito que 

quisermos,  cada  nome  de  variável  em  C  deve 

começar com uma letra, o resto do nome pode ser 

composto  de  letras,  números  e  caracteres  de 

sublinhado.  A  linguagem  C  reconhece  as  letras 

maiúscula e minúscula como sendo diferentes.  

finalmente, 



você 

não 


pode 

usar 


as 

palavras-chave do C como 

main

, para nomear as 



variáveis. 

Palavras-chave 

são 

constantes, 



variáveis  e  nomes  de  funções  que  são  definidas 

como  parte  da  linguagem  do  Arduino.  Usar  um 

nome variável é o mesmo que uma palavra-chave. 

Todas as palavras-chave no desenho irão aparecer 

em vermelho. 

Assim,  você  irá  configurar  uma  área  na  memória 

para  armazenar  um  número  do  tipo  inteiro  e  ter 

armazenado nessa área o número 10. Imagine uma 

variável como uma pequena caixa onde você pode 

manter  as  coisas.  Uma  variável  é  chamada  de 

variável,  porque  você  pode  mudá-la.  Mais  tarde, 

vamos  fazer  os  cálculos  matemáticos  sobre  as 

variáveis  para  ampliar  os  nossos  programas  e 

fazer coisas mais avançadas. 

Em seguida, temos a nossa função 

setup()


 

 

void setup



() { 

  

pinMode



(ledPin, 

OUTPUT


); 

}

 



 

A função setup () é executada uma  vez, e apenas 

uma  vez  no  início  do  programa,  onde  você  vai 

fazer  emitir  instruções  gerais  para  preparar  o 

programa antes das corridas loop principal, como 

a criação de modos de pinos, estabelecendo taxas 

de transmissão de série, etc. 

Basicamente,  uma  função  é  um  bloco  de  código 

montado em um bloco conveniente. Por exemplo, 

se nós criarmos a nossa própria função para levar 

a  cabo  uma  série  matemática  complicada  que 

tiveram muitas linhas de código, poderia executar 

esse  código  quantas  vezes  nós  gostamos 

simplesmente  chamando  o  nome  da  função  em 

vez de escrevê-la novamente: 

 

 



 

Mais  tarde,  vamos  entrar  em  funções  com  mais 

detalhes  quando  começarmos  a  criar  as  nossas 

próprias  manipulações.  No  caso  do  nosso 

programa o 

setup()


 funciona apenas como uma 

 

instrução  para  realizar  alguma  tarefa.  Outra 



função começa com: 

 

void setup()



 

 

e aqui estamos dizendo ao compilador que a nossa 



função é chamada de configuração(setup), que 

não retorna dados (void) e que passamos sem 

parâmetros para ele (parênteses vazio). 

 

int 



myFunc(

int 


x, 

int 


y)

 

 



Neste caso, criamos uma função (ou um bloco de 

código)  chamado 

myFunc

.  Esta  função  foi 



passada a dois inteiros chamados x e y. Uma  vez 

que a função tem término irá retornar a um valor 

inteiro para o ponto depois de onde a nossa função 

foi  chamada  no  programa  (daí  int  antes  do  nome 

da função). 

Todo  o  código  dentro  da  função  está  contido 

dentro das chaves. Um símbolo { inicia o bloco de 

código e um símbolo } termina o bloco. Qualquer 

coisa  entre  estes  dois  símbolos  é  o  código  que 

pertence à função. 

Nós  vamos  entrar  em  maiores  detalhes  sobre  as 

funções  mais  tarde  assim  não  se  preocupe  com 

eles  agora.  Tudo  que  você  precisa  saber  é  que 

neste  programa  temos  duas  funções:  a  primeira 

função  é  chamada  de  configuração  (

setup


)  e  sua 

finalidade  é  dar  a  configuração  necessária  para  o 

nosso  programa  para  trabalhar    antes  que  o  laço 

principal do programa (

loop

) seja executado. 



 

void setup

() { 

  

pinMode



(ledPin, 

OUTPUT


); 

 



Nossa  função  de  instalação  tem  apenas  uma 

declaração  que  é 

pinMode

.  Aqui  nós  estamos 



dizendo ao Arduino que queremos ajustar o modo 

de um dos nossos pinos digitais de saída para ser 

saída,  em  vez  de  entrada.  Dentro  do  parêntese 

colocamos o número de pinos e o modo (

OUTPUT

 

ou 



INPUT

).  Nosso  número  de  pinos  é 

ledPin



que foi anteriormente definido para o valor 10 no 



nosso programa. Por conseguinte, esta declaração 

irá simplesmente dizer para o Arduino que o pino 

digital 10 deve ser configurado para o modo saída. 

 

Como  a  função 



setup()

  é  executada  somente 

uma vez, passemos para o circuito principal: 

 

void loop



() { 

  

digitalWrite



(ledPin, 

HIGH


); 

  

delay



(1000); 

  

digitalWrite



(ledPin, 

LOW


); 

  

delay



(1000); 

}

 



 

void  loop()



  é  a  função  principal  do 

programa e é executado continuamente desde que 

o  nosso  Arduino  esteja  ligado.  Toda  declaração 

dentro  da  função 

loop()

  (dentro  das  chaves)  é 



realizado,  um  por  um,  passo  a  passo,  até  que  a 

parte inferior da função é atingida, e então o laço 

começa  de  novo  no  topo  da  função,  e  assim  por 

diante  para  sempre  ou  até  que  você  desligue  o 

Arduino ou pressione o botão reset

Neste  projeto,  queremos  que  o  LED  ligue,  fique 

por  um  segundo,  desligue  e  permaneça  desligado 

por  um  segundo,  e  repita  isso.  Portanto,  os 

comandos  para  dizerem  ao  Arduino  para  fazer  o 

que está contido dentro do circuito ( ) e funcionar 

como desejamos e repetir infinitamente. 

A primeira declaração é: 

 

digitalWrite



(ledPin, 

HIGH


);

 

 



e  este  escreve  um  sinal  alto  (

HIGH


)  ou  um  valor 

baixo  (


LOW

)  para  o  pino  digital  na  declaração 

(neste  caso 

ledPin


,  que  é  o  pino  digital  10). 

Quando  você  definir  um  pino  digital  para 

HIGH

 

você  está  mandando  5  volts  para o  pino.  Quando 



você configurá-lo para 

LOW


 fica 0 volts. 

Depois disso temos: 

 

delay


(1000);

 

 



Esta declaração simplesmente diz ao Arduino para 

esperar  1000  milissegundos  (1  segundo)  antes  de 

realizar a próxima declaração de que é: 

 

digitalWrite



(ledPin, 

LOW


);

 

 



que  vai  desligar  a  energia  do  pino  digital  10  e 

portanto, desligar o LED. Há então outro atraso da 

declaração por mais 1000 milisegundos e depois a 

função  termina.  No  entanto,  como  este  é  o  nosso 

laço  principal 

loop()


,  a  função  irá  agora 

recomeçar  do  início.  Seguindo  a  estrutura  do 

programa passo-a-passo, podemos ver que é muito 

simples. 

 

// Projeto 1 - LED Pisca-Pìsca 



int 

ledPin = 10; 

void setup

() { 


  

pinMode


(ledPin, 

OUTPUT


); 

void loop



() { 

  

digitalWrite



(ledPin, 

HIGH


); 

  

delay



(1000); 

  

digitalWrite



(ledPin, 

LOW


); 

  

delay



(1000); 

}

 



 

Começamos  por  atribuir  uma  variável  chamada 

ledPin

, dando a essa variável um valor 10. 



 

Em  seguida,  passamos  à  função 



setup()

  que 


simplesmente  define  o  modo  para  o  pino  digital 

10 como saída (

OUTPUT

).  


No laço principal do programa que estabelecemos 

pino digital 10 

HIGH

, envio de 5 V. Então vamos 



esperar por um segundo e, em seguida, desligar o 

5 V do pino 10, antes de esperar outro 1 s. O laço, 

em seguida, começa do início e o LED, portanto, 

liga  e  desliga  continuamente  enquanto  o  Arduino 

estiver energizado.  

Agora que você sabe isso, você pode modificar o 

código para ligar o LED em um período diferente 

de tempo e também desligá-lo por um período de 

tempo diferente. 

Por exemplo, se quisermos que o LED permaneça 

aceso  por  dois  segundos,  em  seguida,  desligado 

meio segundo nós poderíamos fazer o seguinte: 

 

void loop



() { 

  

digitalWrite



(ledPin, 

HIGH


); 

  

delay



(2000); 

  

digitalWrite



(ledPin, 

LOW


); 

  

delay



(500); 

}

 



 

ou talvez você gostaria que o LED fique desligado 

por 5 segundos e, em seguida, piscar rapidamente 

(250 ms), como o LED indicador de um alarme de 

carro, então você poderia fazer isso: 

 

void loop



() { 

  

digitalWrite



(ledPin, 

HIGH


); 

  

delay



(250); 

  

digitalWrite



(ledPin, 

LOW


); 

  

delay



(5000); 

}

 



 

ou fazer o LED ligar e desligar muito rápido: 

 

void loop



() { 

  

digitalWrite



(ledPin, 

HIGH


); 

  

delay



(50); 

  

digitalWrite



(ledPin, 

LOW


); 

  

delay



(50); 

}

 



 

Variando entre ligar e desligar o LED, você pode 

criar qualquer efeito que desejar. 

 

 



Projeto  2  -  Código  Morse  SOS 

sinalizador

 

 

Para  este  projeto,  vamos  deixar  o  circuito 



exatamente do mesmo jeito configurado como no 

Projeto  1,  mas  teremos  algumas  diferenças  no 

código  para  fazer  o  display  LED  emitir  uma 

mensagem em código Morse. Neste caso, faremos 

com que o LED sinalize as letras S.O.S., que é o 

código Morse internacional de sinal de socorro. 

O  código  Morse  é  um  tipo  de  codificação  que 

transmite  letras  e  números  usando  padrões 

ON

  e 


OFF

.  Ele  é,  portanto,  bem  adequado  para  os 

nossos 

sistemas 



digitais 

como 


podemos 

transformar  um  LED  ligado  e  fora  do  padrão 

necessário para soletrar uma palavra ou uma série 

de caracteres. 

Neste  caso  estaremos  sinalizando  S.O.S.  que  no 

alfabeto  do  código  Morse  é  de  três  pontos  (flash 

curto),  seguido  por  três  traços  (flash  de 

comprimento  longo),  seguido  por  três  pontos 

novamente. 

Podemos,  portanto,  agora  com  código  do  nosso 

esboço  piscar  o  LED 

ON

  e  fora  deste  padrão, 



sinalizando  SOS.  Digite  o  código  para  criar  uma 

nova  configuração.  Verifique  se  o  seu  código  é 

livre  de  erros  e,  em  seguida,  envie-o  para  o  seu 

Arduino. 

Se tudo correr bem você vai ver agora o LED em 

flash  o  código  sinal  Morse  SOS,  aguarde  5 

segundos,  em  seguida,  repita.  Então,  vamos  dar 

uma  olhada  neste  código  e  descobrir  como  ele 

funciona. 

 

// Projeto 2 – Codigo Morse SOS 



// LED connected to digital pin 10 

int 


ledPin = 10; 

// run once, when the sketch starts 

void setup

() 


// sets the digital pin as output 

pinMode

(ledPin, 



OUTPUT

); 


// run over and over again 

void loop

() 


// 3 dits 

for 

(

int 



x=0; x<3; x++) { 

  digitalWrite

(ledPin, 

HIGH


); 

// sets the 

LED on 

  delay


(150); 

// waits for 150ms 

  digitalWrite

(ledPin, 

LOW

); 


// sets the 

LED off 


  delay

(100); 


// waits for 100ms 

// 100ms delay to cause slight gap 



between letters 

delay


(100); 

// 3 traços 

for 

(

int 



x=0; x<3; x++) { 

  digitalWrite

(ledPin, 

HIGH


); 

// sets the 

LED on 

  delay


(400); 

// waits for 400ms 

  digitalWrite

(ledPin, 

LOW

); 


// sets the 

LED off 


  delay

(100); 


// waits for 100ms 

// 100ms delay to cause slight gap 



between letters 

delay


(100); 

// 3 dits again 

for 

(

int 



x=0; x<3; x++) { 

  digitalWrite

(ledPin, 

HIGH


); 

// sets the 

LED on 


 

  delay



(150); 

// waits for 150ms 

  digitalWrite

(ledPin, 

LOW

); 


// sets the 

LED off 


  delay

(100); 


// waits for 100ms 

// wait 5 seconds before repeating the 



SOS signal 

delay


(5000); 

 



Projeto 2 – Revisão do código

 

 



Assim,  a  primeira  parte  do  código  é  idêntica  ao 

último projeto em que inicializa um pino variável 

e  define-se  o  pino  10  para  ser  uma  saída.  No 

código  principal,  podemos  ver  o  mesmo  tipo  de 

declaração  para  transformar  os  LEDs  ligados  e 

desligados  por  um  período  definido  de  tempo, 

mas desta vez as declarações estão dentro de três 

blocos de código separados. 

O primeiro bloco é o que gera três piscadas  

 

for 



(

int 


x=0; x<3; x++) { 

digitalWrite

(ledPin, 

HIGH


); 

delay


(150); 

digitalWrite

(ledPin, 

LOW


); 

delay


(100); 

 



Podemos  ver  que  o  LED  é  ligado  por  150  ms  e 

então desligado 100 ms. Podemos ver que aquelas 

declarações  que  estão  dentro  de  um  conjunto  de 

chaves  são,  portanto,  um  bloco  de  código 

separado.  Mas,  quando  executamos  o  sketch

podemos  ver  que  a  luz  pisca  três  vezes  e  não 

apenas uma vez. Isso é feito usando o laço 

for


 

for 



(

int 


x=0; x<3; x++) {

Baixar 1.06 Mb.

Compartilhe com seus amigos:
  1   2   3   4   5




©bemvin.org 2020
enviar mensagem

    Página principal
Prefeitura municipal
santa catarina
Universidade federal
prefeitura municipal
pregão presencial
universidade federal
outras providências
processo seletivo
catarina prefeitura
minas gerais
secretaria municipal
CÂmara municipal
ensino fundamental
ensino médio
concurso público
catarina município
reunião ordinária
Dispõe sobre
Serviço público
câmara municipal
público federal
Processo seletivo
processo licitatório
educaçÃo universidade
seletivo simplificado
Secretaria municipal
sessão ordinária
ensino superior
Relatório técnico
Universidade estadual
Conselho municipal
técnico científico
direitos humanos
científico período
espírito santo
Curriculum vitae
pregão eletrônico
Sequência didática
Quarta feira
distrito federal
prefeito municipal
conselho municipal
língua portuguesa
nossa senhora
segunda feira
Pregão presencial
educaçÃo secretaria
recursos humanos
Terça feira
educaçÃO ciência
agricultura familiar