Arduino colaborativo/Tutorial Arduino - Lição 2

Origem: Wikilivros, livros abertos por um mundo aberto.
Saltar para a navegação Saltar para a pesquisa
Diamond-caution.png O título deste módulo não está de acordo com a nomenclatura adotada no Wikilivros e precisará ser renomeado.

: usar minúsculas e títulos mais descritivos

Introdução

OK você começou a configurar o seu Arduino e também descobriu como usar o software para enviar sketches para a placa. O Próximo passo é começar a escrever os seus próprios sketches. Começaremos de modo fácil, apenas modificando algo que já funciona.

Para começar, vamos explorar bem o esboço Blink, olhando para cada linha e tentando entender o que ele está fazendo.

Então, vamos começar a cortar o sketch!

Blinkie

Inicie o software Arduino e abra o sketch exemplo Blink, como fez na Lição 1.

O sketch em sí é inicializado na área de entrada de texto do software Arduino. Sketches são escritos no texto, assim como um documento. Quando você seleciona Compile / Verify a partir do menu, o software Arduino olha o documento e traduz para a linguagem de máquina do Arduino - que não é muito legível para nós humanos, mas é de fácil entendimento para o Arduino.

Sketches são escritos em C, que é uma linguagem de programação que é muito popular e poderosa. Demora um pouco para se acostumar, mas vamos passar por estes exemplos lentamente.


/ * 
* Blink 
* 
* O exemplo Arduino básico. Acende um LED por um segundo, 
* Então apaga-o por um segundo, e assim por diante ... Nós usamos o pino 13, pois, 
* Dependendo da sua placa Arduino, tem um LED embutido 
* ou um resistor de modo que você só precisa de um LED.(Nas placas Duemilanove e UNO temos tanto o LED quanto o resistor). 
* 
* Http://www.arduino.cc/en/Tutorial/Blink 
* / 
int ledPin = 13; / / LED conectado ao pino digital 13
void setup () / / Ocorre uma vez, quando o skecth é inicializado 
{ 
 pinMode (ledPin, OUTPUT); / / define o pino digital como saída 
} 
void loop () / / Ocorre sempre, como em um laço infinito. 
{ 
 digitalWrite (ledPin, HIGH); / / define o pino do LED em nivel lógico alto(Deve acender o LED) 
 delay (1000) / / espera por um segundo 
 digitalWrite (ledPin, LOW); / / define o pino do LED em nivel logico baixo(Deve apagar o LED) 
 delay (1000) / / espera por um segundo 
} 

Comentários

Vamos examinar este sketch em detalhes a partir da primeira seção:

/ * 
* Blink 
* 
* O exemplo Arduino básico. Acende um LED por um segundo, 
* Então apaga-o por um segundo, e assim por diante ... Nós usamos o pino 13, pois, 
* Dependendo da sua placa Arduino, tem um LED embutido 
* ou um resistor de modo que você só precisa de um LED.(Nas placas Duemilanove e UNO temos tanto o LED quanto o resistor). 
* 
* / 

Este é um comentário, ou seja, é um texto que não é utilizado pelo Arduino, ele está lá para ajudar a entender o que está acontecendo. Você pode dizer se alguma coisa. É um comentário, porque há um * / no começo e um * / no final. Qualquer coisa entre os / * e * / é ignorado pelo Arduino. Neste exemplo, a pessoa que escreveu o comentário decidiu torná-la bonita e adicionar * em cada linha do comentário, mas isso não é necessário. Comentários são muito úteis e eu o encorajo que a cada sketch feito você faça um comentário no inicio com informações do tipo como quem a escreveu, quando você escreveu e o que seu sketch deveria fazer.

Variáveis

Vamos olhar para a linha seguinte:

int ledPin = 13; / / LED conectado ao pino digital 13.

Esta é a primeira linha de código de instrução real. Também é extremamente diferente de Inglês,Espanhol,Português (ou qualquer outra língua humana). A primeira parte podemos facilmente compreender é a parte à direita, que também é um comentário. Acontece que se você quiser fazer um comentário pequeno, você pode usar / / assim como / * * /. / / É muitas vezes usado para um pequeno ou uma linha de comentários.

O resto da linha, o que está antes do / /, é o que é chamado de declaração, que é basicamente como uma sentença de computador. Assim como muitas sentenças humanas são encerradas com um . (Ponto), todas as setenças de um computador terminam em ; (ponto e vírgula)

OK tudo o que resta é a declaração em si, o que acaba por ser uma frase dizendo ao computador que gostaríamos de criar uma caixa nomeada ledPin e colocar o número 13 na caixa. Se você lembrar da sua matemática, você deve se lembrar que a caixa é também conhecido como variável.

tipo de caixa nome da caixa = coisas-para-pôr-na-caixa
int ledPin = 13

A primeira parte desta frase é int, que é o reduzido de integer, que é uma maneira elegante de dizer: número inteiro.

A segunda parte desta frase é ledPin que é o nome da caixa(variável).

A terceira parte é uma =, que basicamente diz que a variável (caixa) chamado ledPin deve assumir o valor do que vier depois da = .

A quarta parte é o 13, um número inteiro (integer) que é atribuído a variável ledPin.

Procedimentos

Vamos passar para a próxima seção:


void setup() // executado uma vez, quando o sktech inicia {

 pinMode(ledPin, OUTPUT);      // define o pino digital como saída

}


  Temos dois comentários, cada um começando com / /. Já que entendemos comentários, vamos pular essa. Vemos também que no meio há uma declaração, sabemos que é uma, pois termina com um ; (ponto e vírgula), no entanto há um monte de outras coisas antes e depois dele. 
  Este monte de código é um exemplo de um procedimento, um procedimento é uma coleção de declarações, é usado para agrupar declarações de modo que possamos nos referir a todas eles com um nome. É apenas como um procedimento que usamos para executar uma tarefa passo a passo.
  Para entender melhor os procedimentos, vamos usar uma analogia com os tipos de procedimentos que estamos acostumados.


clean cat wash the cat(dirty cat) //Procedimento para limpar o gato { turn on the shower. find the cat. grab the cat. put cat under shower. wait 3 minutes. // Espera o gato se limpar. release cat. }


  Este é um procedimento para lavar o gato. O nome do procedimento é wash the cat , ele usa um gato sujo como entrada e retorna um gato limpo na saída. Há dois chaves, uma chave para abrir { e uma para fechar {, isso é usado ​​para indicar o início e o fim do procedimento. Dentro do procedimento há várias declarações, indicando o procedimento correto para lavar um gato. Se você executar todas as instruções, então você deve ser capaz de transformar um gato suja em um gato limpo.

Olhando de novo para o processo, vemos que ele é chamado de setup, não tem valores de entrada e ele retorna void . Agora, provavelmente você está se perguntando "o que é void? " Bem, isso é uma forma científica da computação de dizer nada . Ou seja, este procedimento tem nada de retorno. (Isso não significa que ele não faz nada, apenas que ele não tem um número concreto ou qualquer outra coisa, para mostrar quando a sua ação completa).


void setup() // Executa uma vez, quando o sketch começa


Há uma ação nesse procedimento:


pinMode(ledPin, OUTPUT); // coloca o pino digital como saída


Voltaremos a esta declaração em detalhes mais tarde, basta dizer que é uma maneira de dizer ao Arduino que gostaríamos de ver com um dos pinos físico no chip do processador principal.


Chamadas de Procedimento

Vamos para o próximo grupo de texto:


void loop() // Executa vária vezes {

 digitalWrite(ledPin, HIGH);   // Acende o LED
 delay(1000);                  // Espera um segundo
 digitalWrite(ledPin, LOW);    // Desliga o LED
 delay(1000);                  // Espera um segundo

}

  Usando nossas técnicas já bem afiadas, reconhecemos que o texto à direita são todos os comentários. Reconhecemos, também, um outro procedimento, este chamado de loop que também não tem nenhuma entrada ou saída. Este procedimento tem várias instruções, uma após a outra.
  Vamos pular a primeira declaração para agora e ir direto para a instrução # 2.
  As segunda e quarta funções são as mesmos, e tem algo a ver com um atraso . Estas declarações são muito semelhantes ao "wait three minutes" comando em nosso procedimento de lavagem de gato. Esta declaração diz: "Caro Arduino. Pare o que você está fazendo por um curto período de tempo. Obrigado!" 
  Para fazer isso, a instrução realiza uma chamada de procedimento. Basicamente, queremos que o Arduino faça uma pausa, mas não sei bem como fazer isso, para nossa sorte, alguém escreveu um procedimento chamado de atraso que podemos chamar para fazer o trabalho para nós. Tipo como se nós precisassemos fazer os nossos impostos e nós não sei como, convocamos um contador para fazer isso por nós, dando-lhes a entrada de documentos e declaração de imposto de obter como resultado.


Isso significa que em algum lugar há um procedimento assim:

(Claro que esse exemplo não é um código)

O procedimento delay (atraso) funciona muito bem, basta dizer quantos milissegundos (em milésimos de segundos) de espera e ele fará o trabalho para nós.

Voltando a primeira declaração, vemos que ela é também um procedimento de chamada. Nesse caso um procedimento chamado digitalWrite. Também pularemos uma parte desse detalhe, exceto para explicar que esse procedimento ativa e desativa um dos pinos do Arduino.

Procedimentos Especiais - Setup() e Loop()

Esses procedimentos são extremamente importantes, quando o Arduino é religado ele sempre faz o que está explicito na função setup primeiro, depois ele faz o que está indicado na função loop e faz isso de novo, de novo... Para sempre. Ou até você desligá-lo.


Modificando o Exemplo

Agora que analisamos todo o programa é hora de fazermos algumas mudanças. Em seu software do Arduino altere o delay para 500ms como mostrado abaixo:

Caso você tente salvar o esboço você verá o seguinte aviso:
Então basta renomear seu código. Você pode chamá-lo de MyBlink por exemplo:
Para Compilar/Verificar o esboço e fazer o Upload dele use as instruções da Lição 1.
Uma vez que o Arduino tenha recebido o código você poderá ver o LED piscar mais rápido que antes.

Caso isso não esteja ocorrendo verifique:
  • Você mudou o delay para 500 milissegundos?
  • A compilação foi bem sucedida? (O aviso deve ser o mesmo da imagem acima)
  • O Upload foi bem sucedido? (O aviso deve ser o mesmo da imagem acima)

Exercícios
Agora é a hora de você fazer modificações no código e experimentar diferentes valores para o delay.

Exercício 1.
Modifique seu código para que o LED acenda por 100 milissegundos e se apague por 900.

Exercício 2.
Modifique seu código para que o LED acenda por 50 milissegundos e se apague por 50. O que acontece?

Exercício 3.
Modifique seu código para que o LED acenda por 10 milissegundos e se apague por 10. O que acontece?


Parabéns você terminou a segunda lição!

Nela você examinou detalhadamente o código Blink (piscar) e aprendeu um pouco da linguagem Arduino. Também aprendeu como modificar um código e praticou como fazer o upload dele.