9 - Trabalho

 Vamos trabalhar.... Vamos carregar um caminhão de areia:

Serão muitas horas de trabalho, certo?

Mas, se forem sacos de areia, será mais rápido, porém o esforço será muito maior!

Então podemos entender que trabalho é uma função do esforço (energia) e do tempo gasto na tarefa. Para realizar o mesmo trabalho podemos diminuir o tempo e aumentar a energia gasta... E vice-versa! Não vamos entrar nos mistérios da Física.... É doloroso demais para nossos objetivos.

Muitas vezes nossa "máquina" realiza um trabalho, gasta energia, e leva um tempo para isso (será este o motivo de se usar tanto "delay" na programação dela?)

Como já vimos, o Arduino tem 20 pinos (portas) que podem ser usadas para saída (OUTPUT) ou entrada (INPUT). Mas tudo é digital, ou seja, ou sai toda energia ou não sai nada.

Se pretendemos controlar o brilho de uma lâmpada, por exemplo, teremos que diminuir a quantidade de energia neste tempo... Mas a energia tem sempre o máximo de 5 Volts. É digital! Zero ou tudo!

E se pudermos dividir a saída (modular o pulso)?

Neste caso a "média" da energia entregue seria menor, controlando a luminosidade (trabalho) da lâmpada...

O Arduino tem seis pinos chamados PWM que podem fazer isso. Modular a saída "imitando" uma energia analógica (parcial, ou variável).

Estes pinos são os de número 3, 5, 6, 9, 10 e 11.

Tais saídas podem ser "divididas" em 255 frações, de 0 a 255. E podemos dizer quantas destas frações devem sair de cada vez.

Pronto... Controlamos a quantidade de esforço que ele libera para nossa máquina!

Como "lição de casa", procure o significado de PWM na internet.

 

FAZENDO UMA "MÁQUINA" DE LUMINOSIDADE VARIÁVEL

Antes de continuar você precisa fazer uma montagem para nossos estudos. Consiste de um LED e um resistor de 120 ohms (para limitar a corrente de saída do Arduino, pois o "coitadinho" só fornece 40 miliamperes (em caso de dúvida reveja o capítulo 3 – Eletricidade e Magnetismo).

Usaremos o pino 11 que é uma das saídas PWM... Mas podemos usar qualquer outro PWM!

... E vamos iniciar um novo programa e chamá-lo de "potencia-v01" (Chique, né? Versão 01, pois iremos mudar aos poucos).

No setup informamos ao Arduino que iremos usar o pino 11 como saída.

No loop informaremos que a saída será a fração de 250 (dos 255 possíveis).

Depois mudamos a saída para a metade e comparamos a diferença de brilho.

 

void setup(){ //**********************************************************

pinMode(11,OUTPUT); //pino 11 como saida para o LED

}

 

void loop(){ //***********************************************************

digitalWrite(11,250); //libera 250 partes das 255 modulaveis

digitalWrite(11,124); //libera 124 partes das 250 modulaveis

}

Se você fez a montagem da "máquina" e carregou o programa viu que nada aconteceu...

Não fique bravo... Ainda temos mais algumas coisas para aprender.

TEMPO DE RETENÇÃO

Existe uma diferença de tempo entre a imagem que chega aos nossos olhos e o cérebro identificar a coisa.

O fenômeno da persistência retiniana foi pela primeira vez contrariado pela teoria da Gestalt, que o interpreta como um trabalho do cérebro, que associa imagens distintas, podendo criar assim a ilusão do movimento....

... Um filme de celulóide é rodado a 24 fotogramas por segundo. Hoje o vídeo digital (ou DV, digital video) é gravado a 25 (Europa) ou 29.97 q/s (cerca de 30 quadros por segundo - EUA).

https://pt.wikipedia.org

Então precisamos um tempo para ver o efeito de "escurecimento" da luz do LED. Este tempo deve ser de 30 quadros em 1000 milisegundos , ou 33 milisegundos por quadro.

digitalWrite(11,250); //libera 250 partes das 255 modulaveis

delay(30);

digitalWrite(11,124); //libera 124 partes das 250 modulaveis

delay(30);

Pronto... Agora você refez tudo, carregou e .... NADA! Não funcionou!

Coloque-se no lugar do Arduino. Ele foi informado que deve fornecer uma saída DIGITAL...

digitalWrite(11, 124));

Foi o que ele fez. Liberou tudo... Talvez devesse ser informado que a saída era modulada, parcial, analógica... Uma sutil diferença no comando!

analogWrite(11,250); //libera 250 partes das 255 moduláveis

delay(40);

analogWrite(11,124); //libera 124 partes das 250 moduláveis

delay(40);

Acrescente um "charminho": vamos "apagar" o LED e aguardar 2 segundos antes de reiniciar o ciclo...

digitalWrite(11,LOW); // não precisa ser analógico pois estamos cortando a corrente do pino

delay(2000);

mas, se quiser, pode escrever analogWrite(11,0); Agora o programa ficou assim:

 

/*

* Controlando a potência de saida

* por Carlos Pires

* em 23/10/2017

*/

void setup(){ //**********************************************************

pinMode(11,OUTPUT); //pino 11 como saida para o LED

} //fim do setup

 

void loop(){ //***********************************************************

analogWrite(11,250); //libera 250 partes das 255 modulaveis

delay(40);

analogWrite(11,124); //libera 124 partes das 250 modulaveis

delay(40);

digitalWrite(11,LOW); // não precisa ser analógico pois estamos cortando a corrente do pino

delay(2000);

} //fim do loop

Tente agora! (E não esqueça de salvar caso funcione).

Tente mudar os valores do PWM, como 150 para o brilho forte e 5 para o brilho fraco. Altere o tempo de delay...

Até estou tentado a lhe propor uma lição de casa onde você varie a saída de 5 a 250 de um em um...Mas seria maldade propor que escreva 500 linhas de programa...

Mas, existe uma maneira de variar o loop e ver o LED ir do "apagado" ao "brilho máximo" lentamente... Imagine que seria comandar o Arduino desta maneira:

para (a "potência" variar de 250 a 5, diminuindo um para cada ciclo)

{ analogWrite(11, potência); delay(30); }

 

INSTRUÇÃO "for"

Primeiro criamos uma variável chamada potencia (não esqueça de apresentá-la antes do setup) que irá variar de 5 a 250. Agora traduzimos a frase anterior para a linguagem C++ do Arduino:

/*

* Controlando a potência de saida

* por Carlos Pires

* em 23/10/2017

*/

int unsigned potencia; //variavel inteira e positiva (unsigned)

void setup() //**********************************************************

{

pinMode(11,OUTPUT); //pino 11 como saida para o LED

} //encerra o setup

 

void loop() //***********************************************************

{

for (potencia=250; potencia>5; potencia--)

{ //inicia as instruções do "for"

analogWrite(11,potencia);

delay(30);

} //encerra as instruções do "for"

analogWrite(11,0); //apaga o LED

delay(2000); //espera 2 segundos antes de reiniciar o ciclo

} //encerra o loop

onde: instrução: for ( condicoes da instrucao; ) { instrucoes do for }

potencia = 250: início do valor da variavel potencia

poência > 5: limite do valor

potencia --: decrescimo de uma unidade a cada ciclo

Teste novamente. Experimente mudar os valores. Salve como " potencia_v02" (segunda versão).

Deve ter observado que, a partir do "brilho" 150, é mais difícil perceber a variação da luminosidade. Isso ocorre pois a sensibilidades de nossos sentidos não cresce numa escala aritmética, e sim logarítmica. Este é o caso da Escala Richter dos terremotos ou da intensidade sonora, ou ainda para a intensidade luminosa das estrelas. (O exemplo abaixo não está na mesma escala destas medidas).

Pode iniciar o valor da "potencia = 150" por exemplo, já que o excesso não será percebido.

Lembre-se disso quando fizer a "máquina" agir sobre nossos sentidos

Para controlar um motor é a mesma coisa. Porém tem que agir sobre a ponte "H", formada por transistores ou outro tipo de drive de potência.

O exemplo mais simples é o uso de um único transistor.

O diodo de proteção serve para evitar a queima do transistor de uma "corrente reversa" gerada pelo campo magnético do motor.

Uma ponte "H" pode reverter o sentido do giro do motor, como já vimos.

Pesquise quais componentes e como construir o circuito eletrônico.