-
Você sabe o que é programação
orientada a objeto?
-
Hoje, nós vamos discutir os seus
recursos para o ambiente do ESP32.
-
A programação orientada a objeto
ou POO,
-
é um recurso muito comum
em linguagens C++
-
e outras linguagens como o Java.
-
A sua vantagem é que é uma alternativa
para a programação estruturada
-
e é bom entender o que é programação
estruturada e o que é POO.
-
Na programação estruturada
o fluxo é de cima para baixo
-
ou da esquerda para direita.
-
Isso é, o compilador verifica as linhas
de cima para baixo,
-
da esquerda para direita,
ao fazer a sua compilação
-
E se caso acontecer alguma
falha na compilação,
-
ele te indica o erro e o programador
deve fazer essa correção.
-
O POO é também assim
em termos de compilação.
-
Porém, não é exatamente
de cima para baixo,
-
porque quando você começa
a programar em POO
-
as suas funções ficam todas
lá em cima,
-
mas não quer dizer que o compilador
passou compilando linha a linha.
-
Vejamos uma prática.
-
Nesse código,
que é o nosso famoso pisca pisca,
-
eu tenho aqui à direita um LED vermelho
-
com o seu resistor de 100 homens.
-
Só lembrando que a necessidade do resistor
é para que eu não ultrapasse a corrente
-
nominal de funcionamento do LED, ou seja,
para que ele não queime na prática.
-
Aqui no simulador isso não acontece.
-
Não é uma queima, mas na prática sim.
-
Eu liguei o pino negativo
que é o coletor do LED
-
no GND do SP 32
-
e o pino positivo que é a letra A de anodo
-
passa pelo resistor que vai para esse pino
aqui que é o 13.
-
E assim eu invoquei aqui o pino 13
-
como output no void setup.
-
Esse é um exemplo de linguagem estruturada
porque ele é de cima
-
para baixo, da esquerda para a direita.
-
Ou seja,
nós temos aqui o vídeo setup ovoide,
-
o loop que faz o pisca LED ser carregado,
invocado.
-
A novidade é essa aqui, esse pisca leve.
-
Hoje está em forma de função.
-
Eu poderia ter colocado esse DJ Write
-
com o Ray de estourar
e com o Low aqui dentro.
-
Dessa forma
-
no lugar do
-
pisca LED que iria funcionar
perfeitamente.
-
Aí eu volto aqui
com um tab para organizar.
-
E assim ele pescaria.
-
Pois bem, na linguagem de hoje
-
que a gente está trabalhando
com programação orientada a objeto,
-
ao invés de colocar essa linha
que está sendo repetida
-
dentro do VAR de looping, eu posso
colocá la de fora, ou seja, numa função.
-
Então eu vou apagar fazendo Control Z aqui
-
e retornar o que eu estava
-
do jeito que está aqui, o que acontece?
-
Esse pisca LED é uma função
porque a sintaxe dela é uma palavra
-
que você vai escolher e entre parênteses
-
eu vou colocar dois argumentos nessa hora.
-
Esses dois argumentos estão sendo passados
aqui para cima
-
porque a palavra pisca led se repete
-
dentro do void,
que significa que ele não retorna nada.
-
Ou seja,
essa função aqui não vai me retornar nada,
-
ela não vai me trazer uma variável,
o conteúdo de uma variável,
-
ela simplesmente
vai fazer uma ação de piscar.
-
O led está dependendo de quem?
-
De dois argumentos
dos quais eu estou publicando
-
ou declarando na verdade,
aqui dentro desses parentes.
-
Veja que eu tenho aqui o int, que é
um tipo de declaração com a variável pino.
-
Aí eu tenho uma vírgula e outra variável
-
do tipo o tempo
e a tipagem dela inteira de novo.
-
Olha quantos argumentos eu quiser
colocar, eu vou colocando aqui dentro
-
que eu precisava colocar aqui,
separando por vírgula.
-
No entanto, do jeito que eu fiz
a minha lógica, eu só preciso de dois,
-
porque eu estou indicando aqui,
pela minha lógica,
-
o pino que o LED está ligado
e o tempo que ele vai ser o intervalo,
-
a cadência das piscadas
que ele vai precisar.
-
E assim esses parâmetros são passados
aqui para dentro.
-
O pino recebe o 13, assim como o tempo
-
recebe o 500, porque são respectivos.
-
Aí a ordem que importa aqui dentro
que eu coloquei
-
separado por vírgula,
que vai casar lá dentro da minha função.
-
E assim como o pino
está declarado aqui como inteiro,
-
ele é local nessa declaração,
porém ela é local e é pública.
-
Visivelmente aqui dentro
-
eu consigo enxergar o conteúdo de pino
aqui dentro dessa função.
-
Então ela vai vir aqui automaticamente.
-
No lugar desse pino.
-
Aqui vai estar o número 13 do jeito
que veio transferido lá do void loop
-
até chegar aqui. E o conteúdo de tempo.
-
Esse parâmetro ele
-
recebe o 500 e aí
ele vai ser utilizado aqui.
-
Aqui dentro do delay.
-
Note que quando você está fazendo
uma função,
-
o nome que está dentro do void loop,
que é onde vai carregar,
-
precisa bater com o nome
que está do lado de fora, se não, a função
-
não coincide, não casa
e quando você fizer a sua função,
-
você está ainda fazendo uma linguagem
estruturada, mas com um pé
-
dentro da programação orientada a objeto.
-
A vantagem de você fazer funções
é que você está fazendo
-
pequenas pequenas ferramentas
ou pequenos pacotes.
-
Utilizar todos mais de uma vez.
-
Nesse caso do pisca pisca,
ele é muito simples
-
para requerer uma função,
mas ainda assim, didaticamente
-
é importante você entender
para uma linguagem mais complexa
-
ou um programa mais complexo
que requer mais funções.
-
Aí sim vale a pena criar essas funções
para você reutilizar
-
parte do seu código através de funções
e não deixar o seu void de loops
-
super carregado com códigos
que serão repetidos lá embaixo.
