Arduíno orientado a objetos
Salve meu povo!
Seu muito fã da orientação a objetos e, por isso, não via a hora de começar a programar o Arduíno dessa maneira. Minha experiência com OOP é (era) única e exclusivamente com o PHP, então estranhei um pouco a maneira como o C++ trabalha, mas já peguei a manha.
- [Classe].h: é o cabeçalho da classe, contém a estrutura de métodos e propriedades dela.
- [Classe].cpp: é o código da classe, onde se operacionalizam os métodos.
- keywords.txt: contém a lista de métodos (para questão de formatação).
Além disso, dentro da pasta da classe pode haver uma pasta chamada "examples", que contém os exemplos de uso da classe.
Até que fica organizado.
int vermelho = 8;
void setup() {
pinMode(vermelho, OUTPUT);
}
void loop() {
digitalWrite(vermelho, HIGH);
delay(500);
digitalWrite(vermelho, LOW);
delay(500);
}
Ok. Isso funciona. Mas imagine 3 cores. Agora imagine 20 cores... Pois é... E se operarmos o pino como um objeto? E se cada pino puder ter propriedades e métodos associados? Pois bem, é aí que eu quero chegar. Vou criar uma classe para tratar o pino como um objeto e associar métodos que executam ações costumeiras e vamos ver como fica.
#include "Arduino.h"
class Pin {
public:
Pin(int pin); //Número do pino
void mode(int mode); //Modo de operação
void on(); //Ativa o pino;
void off(); //Desativa o pino;
void blink(int duration); //Ativa o pino por um determinado tempo
private:
int _pin; //Guarda o número do pino
int _mode; //Guarda o modo de operação
}
#include "Arduino.h";
#include "Pin.h";
Pin::Pin(int pin) {
_pin = pin;
}
void Pin::mode(int mode) {
_mode = mode;
}
void Pin::on() {
digitalWrite(_pin, HIGH);
}
void Pin::off() {
digitalWrite(_pin, LOW);
}
void Pin::blink(int duration) {
Pin::on();
delay(duration / 2);
Pin::off();
delay(duration / 2);
}
Claro, existem outros métodos para o pino, mas, para início de conversa, vou usar só esses aí.
Pin KEYWORD1
mode KEYWORD2
on KEYWORD2
off KEYWORD2
blink KEYWORD2
Note que a classe recebe o tipo KEYWORD1, já os métodos da classe recebem o tipo KEYWORD2.
// ----- Maneira antiga -----
int vermelho = 8;
void setup() {
pinMode(vermelho, OUTPUT);
}
void loop() {
digitalWrite(vermelho, HIGH);
delay(500);
digitalWrite(vermelho, LOW);
delay(500);
}
// ----- Fim do código -----
// ----- Com OOP -----
#include <Pin.h>
Pin vermelho(8);
void setup() {
vermelho.mode(OUTPUT);
}
void loop() {
vermelho.blink(1000);
}
// ----- Fim do código -----
O código OOP economizou 2 linhas. Já é um começo. Se eu quiser adicionar mais um LED ao segundo código basta declarar um novo pino, por exemplo: Pin amarelo(9), escolher o modo com amarelo.mode(OUTPUT) e fazê-lo piscar com amarelo.blink(1000). Já no código anterior fica mais complicado, preciso adicionar mais linhas para ter o mesmo efeito.
Claro, qualquer sugestão será muito bem vinda.
Seu muito fã da orientação a objetos e, por isso, não via a hora de começar a programar o Arduíno dessa maneira. Minha experiência com OOP é (era) única e exclusivamente com o PHP, então estranhei um pouco a maneira como o C++ trabalha, mas já peguei a manha.
C com Orientação a Objetos
No arduíno, todas as classes que podem ser usadas no projeto ficam dentro de pastas específicas guardadas dentro da pasta "libraries". No RPi a pasta fica em /home/[usuário]/sketchbook. No Windows, C:\Users\[usuário]\Documents\Arduino (ficava até antes de eu trocar). Pois bem, cada classe tem sua pasta que contém os seguintes arquivos:- [Classe].h: é o cabeçalho da classe, contém a estrutura de métodos e propriedades dela.
- [Classe].cpp: é o código da classe, onde se operacionalizam os métodos.
- keywords.txt: contém a lista de métodos (para questão de formatação).
Além disso, dentro da pasta da classe pode haver uma pasta chamada "examples", que contém os exemplos de uso da classe.
Até que fica organizado.
Manipulando os pinos
Eu percebi que, constantemente, ligamos e desligamos pinos e isso acontece repetidas vezes. Se eu quiser, por exemplo, acender o LED vermelho que está no pino 8, devo fazer assim:int vermelho = 8;
void setup() {
pinMode(vermelho, OUTPUT);
}
void loop() {
digitalWrite(vermelho, HIGH);
delay(500);
digitalWrite(vermelho, LOW);
delay(500);
}
Ok. Isso funciona. Mas imagine 3 cores. Agora imagine 20 cores... Pois é... E se operarmos o pino como um objeto? E se cada pino puder ter propriedades e métodos associados? Pois bem, é aí que eu quero chegar. Vou criar uma classe para tratar o pino como um objeto e associar métodos que executam ações costumeiras e vamos ver como fica.
Pin.h
Esse é o cabeçalho da classe. Aqui todas os métodos e propriedades são descritos.#include "Arduino.h"
class Pin {
public:
Pin(int pin); //Número do pino
void mode(int mode); //Modo de operação
void on(); //Ativa o pino;
void off(); //Desativa o pino;
void blink(int duration); //Ativa o pino por um determinado tempo
private:
int _pin; //Guarda o número do pino
int _mode; //Guarda o modo de operação
}
Pin.cpp
E esta é a classe. Aqui todo o processo é operacionalizado.#include "Arduino.h";
#include "Pin.h";
Pin::Pin(int pin) {
_pin = pin;
}
void Pin::mode(int mode) {
_mode = mode;
}
void Pin::on() {
digitalWrite(_pin, HIGH);
}
void Pin::off() {
digitalWrite(_pin, LOW);
}
void Pin::blink(int duration) {
Pin::on();
delay(duration / 2);
Pin::off();
delay(duration / 2);
}
Claro, existem outros métodos para o pino, mas, para início de conversa, vou usar só esses aí.
keywords.txt
Por fim, esse é o arquivo de palavras-chave que a IDE do Arduíno pode usar para marcar corretamente os métodos quando chamados com suas cores de referência.Pin KEYWORD1
mode KEYWORD2
on KEYWORD2
off KEYWORD2
blink KEYWORD2
Note que a classe recebe o tipo KEYWORD1, já os métodos da classe recebem o tipo KEYWORD2.
Comparando os códigos
Agora vamos ver como fica o código para piscar o LED por 1 segundo da maneira antiga e com OOP:// ----- Maneira antiga -----
int vermelho = 8;
void setup() {
pinMode(vermelho, OUTPUT);
}
void loop() {
digitalWrite(vermelho, HIGH);
delay(500);
digitalWrite(vermelho, LOW);
delay(500);
}
// ----- Fim do código -----
// ----- Com OOP -----
#include <Pin.h>
Pin vermelho(8);
void setup() {
vermelho.mode(OUTPUT);
}
void loop() {
vermelho.blink(1000);
}
// ----- Fim do código -----
O código OOP economizou 2 linhas. Já é um começo. Se eu quiser adicionar mais um LED ao segundo código basta declarar um novo pino, por exemplo: Pin amarelo(9), escolher o modo com amarelo.mode(OUTPUT) e fazê-lo piscar com amarelo.blink(1000). Já no código anterior fica mais complicado, preciso adicionar mais linhas para ter o mesmo efeito.
Conclusão
Trabalhar com os pinos do Arduíno no formato de objetos é uma mão na roda. Muitos dos processos repetitivos simplesmente deixam de existir e, de quebra, o código fica mais legível e o sketch fica com a manutenção facilitada. À partir de agora o blog vai criar sketchs orientados a objetos. Vou disponibilizar toda a biblioteca criada para download também em uma página permanente.Claro, qualquer sugestão será muito bem vinda.
Comentários
Postar um comentário