-
Você sabe o que é objetos
e métodos
-
dentro da linguagem de programação
orientada a objetos?
-
Vamos discutir
um pouco mais sobre isso.
-
Dentro da linguagem
de programação orientada objeto
-
nós temos recursos
que vão tornando a programação
-
um pouco mais profissional
e ao mesmo tempo flexível
-
para fazer alterações
rápidas sem quebrar muito o código.
-
Outra vantagem de usar
métodos e objetos
-
é que você pode criar
uma caixa de ferramenta exclusiva
-
para você programador
que tem facilidade em desenvolver
-
uma parte do programa e reaproveitar
isso nos demais programas.
-
Afinal, os bastidores do código
-
não são tão importantes para o usuário
que está usando seu sistema.
-
E você, como programador,
pode ganhar tempo reaproveitando
-
partes do seu código
para projetos futuros.
-
Vejamos aqui uma aplicação prática
-
de como fazer objetos e métodos
usando o pisca pisca.
-
Nesse código nós vamos começar aqui
do nosso "void setup".
-
Percebe que ele está "vazio",
-
já que a parte de programação
do pin mode
-
ou da configuração do pin mode,
-
que é importantíssima para fazer
os pinos se alimentarem
-
elas em vez de estar dentro
do void setup,
-
elas foram parar dentro
da nossa classe.
-
E ainda na sequência nós temos
o "void loop"
-
que vai na verdade instanciar
os nossos métodos.
-
Então, vejamos.
-
O que é um objeto?
O que é um método?
-
Tudo começa antes do "void setup".
-
Percebe que aqui tem uma palavra "Led"
com a letra L maiúscula
-
e um "led1" com letras minúsculas.
-
Essa palavra Led com letra maiúscula
é o nosso objeto.
-
Percebe que aqui em cima
esse Led
-
também aparece com a letra maiúscula.
-
Então o nome que vem
logo abaixo do "public"
-
tem que bater com a palavra
que você está criando lá de fora
-
que vem antes do void setup.
-
Na sequência eu tenho o "led1".
-
Esse led1 faz parte do objeto.
-
Porém, ele não aparece
aqui dentro da classe.
-
Ele vai aparecer lá fora
dentro do "void Loop",
-
que é aonde eu vou instanciar meu objeto.
-
Então eu começo com o "Led"
criando dentro da classe Led maiúscula
-
e o "led1" para fora dele,
aonde eu vou instanciar.
-
Pois bem, percebe que tem um ponto
depois da palavra "led1."?
-
Esse ponto vai me dizer
qual é o comportamento desse objeto.
-
Ou seja,
esse ponto significa método.
-
Método é uma espécie de ação
é o comportamento do objeto.
-
A palavra ".ligar"
está dentro da minha classe
-
e ela faz parte aqui dessa função,
-
dessa pequena função
que é um "digitalwrite".
-
Ou seja, faço o nível lógico alto
-
sair pelo o pino
que está sendo carregado.
-
Já já a gente chega no entendimento disso.
-
Por enquanto você só tem que entender
que dentro do "void ligar"
-
eu faço o nível lógico alto sair.
-
E dentro da função "void desligar"
-
eu faço o "low" sair, ou seja,
eu desabilito o led.
-
Entendido isso, vamos agora
entender como se faz uma classe.
-
Você começa com a palavra "class"
e coloca a palavra "Led" também.
-
A palavra L maiúscula
tem que estar aqui em cima,
-
aqui no "public" e lá do lado de fora.
-
E aí você vai fazer
uma construção da sua classe,
-
sempre com duas partes,
uma parte privada e uma parte pública.
-
Na parte privada
você vai declarar os pinos
-
que serão utilizados dentro desse escopo
e não mais que isso.
-
Então a classe para ela existir,
-
ela precisa ter pequenas gavetas
na memória do microcontrolador.
-
E essas gavetas são as variáveis.
-
Nesse caso,
eu estou declarando a gaveta "pino"
-
como sendo inteira.
-
Na parte pública eu vou colocar aqui
-
o nome do meu objeto
e aí na frente dele
-
eu vou colocar o local onde vai vir
o parâmetro,
-
o primeiro parâmetro quando eu carregá-lo.
-
Então aqui está vindo o parâmetro "p",
-
"p" minúsculo e ele é do tipo inteiro.
-
Quando eu entrar
na minha parte pública
-
eu faço uma transferência
obrigatória aqui de parâmetro.
-
A variável que você declarar
aqui dentro,
-
você precisa jogar para dentro
da privada,
-
da parte privada
que você declarou na etapa anterior.
-
Isso garante o que?
-
Que o seu conteúdo que acabou
de chegar dentro da sua classe,
-
vá direto para um conteúdo privado
para você poder trabalhar aqui dentro
-
e não deixar exposto para os outros
escopos do seu projeto.
-
Isso garante segurança
na hora de montar o projeto
-
e evitar que variáveis
sejam alteradas inadvertidamente.
-
Outra coisa que acontece aqui
é o "pinMode",
-
que é o normal.
-
Isso aqui deveria estar dentro
do void Setup.
-
Por quê nós colocamos aqui?
-
Para mostrar para você
que dentro da parte pública
-
eu posso fazer o que eu bem
entender com o código,
-
mesmo etapas ou comandos
que vão dentro do void setup
-
para desocupar ou tirar de dentro
do void setup
-
etapas que só interessam
quando eu tiver um pisca pisca.
-
Isso aqui então, já está trazendo
para mim uma versatilidade.
-
Se isso aqui for uma ferramenta
que eu encapsulo
-
como sendo um pisca pisca,
-
todos os códigos que eu estiver
precisando um pisca pisca
-
eu não preciso depender do void setup
para ir lá colocar o pinMode,
-
eu já deixo dentro
da minha caixa de ferramenta,
-
independente do que já tem lá
dentro do vai de setup.
-
Eu não tenho que mexer
dentro do void setup
-
eu incluo o pinMode
que é importante para o pisca pisca,
-
para a minha placa,
para meu projeto que tem pisca pisca,
-
não para todos que eu tiver
que colocar um pisca pisca,
-
eu vou lá no void setup
e altero o conteúdo dele.
-
Deixo aqui na classe
e que vai funcionar da mesma forma.
-
E aí está lá "pinMode"
o "pino" e "output".
-
Agora de onde está vindo o pino?
-
O pino, como eu disse,
está vindo da letra "p".
-
E a letra "p"
está vindo da onde?
-
Está vindo da frente do argumento
que está na frente do "Led".
-
Aí você volta lá.
-
Então na linha 19, na linha 20,
olhe que acontece aqui
-
eu coloquei LED como sendo o meu objeto
e o LED um como sendo parte do meu objeto.
-
Só que aí olha o que tem aqui dentro,
um número.
-
Esse número ele está vindo indexado para
exatamente aqui dentro.
-
Só que não aparece a palavra LED
um dentro da classe,
-
porque não tem mesmo que aparecer.
-
Ela aparece do lado de fora
quando eu precisar de invocar ela,
-
porque assim o que eu faço
eu coloco aqui LED um ponto ligar
-
e aí ele vai entender o que
que na frente do led não tem a variável
-
o melhor conteúdo 23
que por sua vez vai cair na letra P
-
que por sua vez vai cair na letra pino,
que por sua vez vai ser carregado
-
no pin mod e depois vai ser instanciado
aqui, ou melhor invocado dentro
-
do método ligar porque
-
você colocou ponto ligar e aí
o ligar é para High.
-
Depois você espera um deley lá embaixo
que ele vai executar isso aqui
-
e vai sair daqui de dentro,
ai ele volta para o Voz de Low.
-
O delay vai ser executado
por 1000 milissegundos ou um segundo
-
e na sequência eu tenho o led
um de novo, ou seja, o mesmo objeto
-
e de um porém com o método diferente
que é o ponto desligar.
-
E aí eu carrego
essa parte do código aonde?
-
Lá com o mesmo pino
que já está na memória,
-
eu faço low e o led apaga.
-
Conclusão
todas as vezes que você criar uma classe
-
você tem que instanciar aqui no começo a
-
o objeto, o nome desse objeto
que vai aparecer lá fora
-
e o pino que você quer carregar com isso.
-
Olha só como ficou nossa voz de loop.
-
Bem enxuto onde eu tenho agora?
-
Aqui só LED um ponto, ligar LED
ou um ponto desligar e eu coloco um delay.
-
Poderia ter colocado esse delay lá dentro
-
do meu voyage ligar
eu coloco ele aqui dentro, põe 1000 aqui
-
por enquanto e
-
vírgula
e aí eu tiraria o delay daqui de dentro.
-
Olha só como que ficaria bem
simples no meu, vai de louco!
-
E olha que eu estou criando
cuidando de dois LEDs
-
num método, ou melhor,
numa explicação aí anterior,
-
eu teria que colocar
dentro do VAR de loop,
-
ligar para o led azul,
depois desligar para o led azul,
-
ligar para o led verde,
desligar para o led verde
-
com incluindo os seus respectivos pinos
e deles.
-
Aqui, do jeito que eu estou fazendo,
eu posso simplesmente colocar
-
1000 aqui dentro.
-
E vai ficar ainda mais enxuto.
-
E aí eu tiraria
-
os meus 500 aqui
-
e assim
os leds estariam na mesma cadência.
-
Eu não vou colocar o play aqui agora,
mas esse é um exemplo para vocês
-
e do jeito que eles estão fazendo aqui,
a gente volta agora para onde estava.
-
Do jeitinho que estava.
-
E agora vamos entender o final.
-
O LED eu faço simplesmente
a ativação dele lá em cima.
-
Espero um segundo depois eu desativo.
-
Ele espera um segundo para o LED dois,
que é o verde.
-
Eu faço a ativação de lá em cima.
-
Espera agora meio tempo, meio segundo
e depois eu desligo.
-
Note que o verde é mais rápido
-
para piscar e o azul é mais demorado.
-
Um segundo para o azul,
meio segundo para o verde.
-
Esse método de fazer a programação
com base em classes
-
para programas mais complexos
e mais elaborados é essencial,
-
porque quando você tiver
que fazer alguma alteração,
-
você vai apenas na classe
e mexe, apenas na class,
-
não na estrutura inteira do void looping
ou do void setup.
-
E quando você acertar
as versões das suas classes,
-
elas são herdadas para programas
futuros, economizando um baita tempo.
