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.

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.