AICSS CAP08 2025 VA01 POO INTRODUCAO E FUNCOES

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 100ohms.

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 há uma queima,
mas na prática, sim.

Eu liguei o pino negativo
que é o coletor do LED

no GND do ESP32

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 void setup,

o void loop,

que faz o piscarLed ser carregado,
invocado.

A novidade é essa aqui,

esse piscarLed hoje está em forma
de função.

Eu poderia ter colocado
esse "digitalWrite"

com o high digitalWrite,
com o Low aqui dentro,

dessa forma,

no lugar do "piscarLed",
que iria funcionar perfeitamente.

Aí eu volto aqui
com um tab para organizar.

E assim ele piscaria.

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 "void loop",
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 "piscarLed" é 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 "piscarLed" 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,

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.

E 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 "tempo"

e a tipagem dela é inteira de novo.

Olha, quantos argumentos
eu quiser colocar,

eu vou colocando aqui dentro,
o que eu precisar vou colocando aqui,

separando por vírgula.

No entanto,
do jeito que eu fiz a minha lógica,

eu só preciso de dois.

Por quê?

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, né?

É 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,

essa declaração é local,
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 recebeu "500"

e aí ele vai ser utilizado
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,

senã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 ferramentas
ou pequenos pacotes

utilizados 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 loop
super carregado

com códigos que serão repetidos
lá embaixo.