Criação de bibliotecas para Arduino

As bibliotecas são comumente usadas no Arduino, elas ajudam consideravelmente na hora de programar.

Neste tutorial eu vou tentar mostrar a criação de uma biblioteca do zero da forma mais simples possível.

Para criar uma biblioteca, você precisa saber manipular o seu módulo, sensor, ou simplesmente um bloco de código sem o auxílio de bibliotecas adicionais, por isso, vamos utilizar um LED RGB, que é de fácil acesso e manipulação.


Requerimentos:

  • Um editor de textos(recomendo o Sublime Text 2 ou Notepad++) ou a própria IDE do Arduino;
  • 1x Led RGB ou 3x Led(coloridos de preferência);
  • 3x Resistores(Pode variar de acordo com seu LED);
  • 1x Arduino

 

Uma biblioteca contém:

  • Uma pasta com exemplo(s);
  • Um .h
  • Um .cpp
  • Um keywords.txt

 

Para iniciar, devemos montar um sketch como base, sem a biblioteca.
Usarei o sketch deste artigo.

#define red 11
#define green 10
#define blue 9
void mudaCor(int r, int g, int b){
 analogWrite(red, r);
 analogWrite(green, g);
 analogWrite(blue, b);
 /*
 * os valores de r, g e b devem ser 0 - 255
 * você também pode usar pinos não-PWM, mas
 * não vai permitir que você controle a
 * intensidade de cada cor, apenas ligado ou
 * desligado.
 */
}
void setup(){
 pinMode(red, OUTPUT);
 pinMode(green, OUTPUT);
 pinMode(blue, OUTPUT);
}
void loop(){
 mudaCor(255, 0, 0); //vermelho
 delay(1000);
 mudaCor(150, 0, 0); //vermelho com intensidade mais fraca
 delay(1000);
 mudaCor(0, 255, 0); //verde
 delay(1000);
 mudaCor(0, 0, 255); //azul
 delay(1000);
 mudaCor(255, 255, 0); //amarelo
 delay(1000);
 mudaCor(255, 0, 255); //roxo
 delay(1000);
 mudaCor(0, 255, 255); //ciano
 delay(1000);
}

Analisando o código, podemos ver que vamos usar 3 variáveis para guardar os pinos, um método para mudar a cor, e definir as saídas OUTPUTs.
Devemos começar criando as pastas e os arquivos:

Pasta LEDRGB_lib:

  • LEDRGB_lib.h
  • LEDRGB_lib.cpp
  • keywords.txt
  • examples

Pasta LEDRGB_lib\examples:

  • Tutorial

Pasta LEDRGB_lib\examples\Tutorial:

  • Tutorial.ino

 

Vamos começar pelo LEDRGB_lib.h, ele é a cabeça da sua biblioteca, ele contém as classes, as variáveis, e os métodos.

Vamos iniciar nossa biblioteca:

#ifndef LEDRGB_lib_h
#define LEDRGB_lib_h

Incluir a biblioteca do Arduino:

#include <Arduino.h>

Criando a primeira classe:
Essa classe chamada LEDRGBPWM vai controlar LEDs RGBs conectados aos pinos PWM, dessa forma é possível definir a intensidade da cor.
Exemplos

  • LEDRGBPWM meuLed(9, 10, 11);
  • meuLed.mudaCor(255, 0, 0); //vermelho
  • meuLed.mudaVerde(100); //altera a intensidade da cor verde para 100

class LEDRGBPWM{  //classe LEDRGBPWM
//o conteúdo dentro de private só é acessível pela da biblioteca
private:
int intensidade(int); //esse método vai evitar que a intensidade ultrapasse 255
int Rpin, Gpin, Bpin;  //variáveis privadas para guardar os pinos
public:
LEDRGBPWM(int, int, int);  //LEDRGBPWM meuLed(pino1, pino2, pino3)
void mudaCor(int, int, int);  //os métodos não precisam do nome dos argumentos.
void mudaVermelho(int);  //cada método deve ser chamado meuLed.metodo(argumentos)
void mudaVerde(int);  //esse método vai alterar a intensidade do led verde
void mudaAzul(int);  //e esse di azul
};

A nossa segunda classe vai tratar dos LEDs RGBs que não estarão conectados aos pinos PWM, apenas digital. A contrução da classe é semelhante ao LEDRGBPWM, com exceção dos métodos, que agora tratam a intensidade com bool/boolean(true e false).

class LEDRGB{
private:
int Rpin, Gpin, Bpin;
public:
LEDRGB(int, int, int);
void muda(boolean, boolean, boolean);
void vermelho(boolean);
void verde(boolean);
void azul(boolean);
};

Concluímos o nosso LEDRGB_lib.h

#endif

 

LEDRGB_lib.cpp
O LEDRGB.cpp é o corpo da biblioteca, nele ficam guardados os métodos que serão utilizados.

Incluímos as bibliotecas  Arduino, e LEDRGB_lib.h

#include <Arduino.h>
#include <LEDRGB_lib.h>

Coloquei esse breve comentário para ficar mais fácil a identificação dos métodos de cada classe.
Classe LEDRGBPWM

//########################################
//LED RGB PWM
//########################################

Primeiro método que vamos chamar, ele é executado quando:
LEDRGBPWM meuLed(pino1, pino2, pino3);
É importante lembrar que agora precisamos definir o nome dos argumentos.

LEDRGBPWM::LEDRGBPWM(int r, int g, int b){
Rpin = r; //essa variável é privada, e vai guardar o pino vermelho
Gpin = g; //usamos os argumentos para passar o pino para essas variaveis
Bpin = b;
pinMode(Rpin, OUTPUT);  //definimos os pinos das cores como saídas
pinMode(Gpin, OUTPUT);  //Nós fazemos isso em setup() quando não utilizamos bibliotecas
pinMode(Bpin, OUTPUT); //com essa biblioteca, isso não será necessário, já que nossa classe vai fazer isso pra gente
}

Esse método vai mudar a intensidade das 3 cores
Repare que temos sempre que colocar o nome da nossa classe seguido de “::” para dizermos a qual classe os métodos pertencem, até mesmo os privados.

void LEDRGBPWM::mudaCor(int ri, int gi, int bi){
analogWrite(Rpin, intensidade(ri));
analogWrite(Gpin, intensidade(gi));
analogWrite(Bpin, intensidade(bi));
}

Esse método da classe LEDRGBPWM muda a intensidade apenas do vermelho.
Para chamar métodos é simples: meuLed.mudaVermelho(valor);

void LEDRGBPWM::mudaVermelho(int ri){
analogWrite(Rpin, intensidade(ri));
}

E esses outros métodos vão mudar a intensidade do verde e azul. Repare que o método privado intensidade aparece para verificar e retornar um valor maior que -1 e menor que 256

void LEDRGBPWM::mudaVerde(int gi){
analogWrite(Gpin, intensidade(gi));
}

void LEDRGBPWM::mudaAzul(int bi){
analogWrite(Bpin, intensidade(bi));
}

Esse método privado vai ser utilizado apenas pela biblioteca, o usuário não tem acesso usando valor = meuLed.intensidade(valor);

int LEDRGBPWM::intensidade(int i){
if(i < 0){
return 0;
}else if(i > 255){
return 255;
}else{
return i;
}
}

Classe LEDRGB
Essa classe é muito parecida com a LEDRGBPWM. Como não podemos alterar a intensidade, vamos controlar as cores da seguinte forma: acesa ou apagada, true ou false

//########################################
//LED RGB NÃO-PWM
//########################################

Também temos que definir os pinos como saída, e salvar os pinos nas variáveis privadas.

LEDRGB::LEDRGB(int r, int g, int b){
Rpin = r;
Gpin = g;
Bpin = b;
pinMode(Rpin, OUTPUT);
pinMode(Gpin, OUTPUT);
pinMode(Bpin, OUTPUT);
}

meuLed.muda(true, false, false) = ligado, desligado, desligado

void LEDRGB::muda(boolean rb, boolean gb, boolean bb){
digitalWrite(Rpin, rb);
digitalWrite(Gpin, gb);
digitalWrite(Bpin, bb);
}

meuLed.vermelho(true) ligado
meuLed.vermelho(false) desligado

void LEDRGB::vermelho(boolean rb){
if(rb){
digitalWrite(Rpin, HIGH);
}else{
digitalWrite(Rpin, LOW);
}
}

Métodos que vão ligar ou desligar as cores restantes.
Usamos o if para verificar se gb é verdadeiro, se sim, acendemos a cor, se não, desligamos a cor.

void LEDRGB::verde(boolean gb){
if(gb){
digitalWrite(Gpin, HIGH);
}else{
digitalWrite(Gpin, LOW);
}
}

void LEDRGB::azul(boolean bb){
if(bb){
digitalWrite(Bpin, HIGH);
}else{
digitalWrite(Bpin, LOW);
}
}

FIM do LEDRGB_lib.cpp

 

keywords.txt
O keywords.txt vai guardar as palavras que queremos coloridas na IDE do arduino, é a parte mais simples, fácil e rápida de se fazer na biblioteca.
As classes devem ser KEYWORD1
Os métodos devem ser KEYWORD2
E as constantesLITERAL1

É importante dizer que a separação entre a palavra e a KEYWORD/LITERAL deve ser TAB, e não espaços.

LEDRGB KEYWORD1
LEDRGBPWM KEYWORD1

mudaCor KEYWORD2
mudaVermelho KEYWORD2
mudaVerde KEYWORD2
mudaAzul KEYWORD2
muda KEYWORD2
vermelho KEYWORD2
verde KEYWORD2
azul KEYWORD2

E finalmente a sua biblioteca ficou pronta, resta agora apenas criar os exemplos.

Abra o arquivo Tutorial.ino contido na pasta examples/Tutorial e faça seu tutorial usando sua biblioteca!

#include <LEDRGB_lib.h>

LEDRGBPWM ledPWM(9, 10, 11);
LEDRGB ledDigital(9, 10, 11);

void setup(){
}

void loop(){
//Com PWM
ledPWM.mudaCor(0, 0, 0);
delay(1000);
ledPWM.mudaCor(100, 0, 0);
delay(1000);
ledPWM.mudaCor(0, 0, 255);
delay(1000);
ledPWM.mudaCor(0, 100, 40);
delay(1000);

//Com Digital
ledDigital.muda(false, false, false);
delay(1000);
ledDigital.muda(true, false, false);
delay(1000);
ledDigital.muda(false, false, true);
delay(1000);
ledDigital.muda(false, true, true);
delay(1000);
}

Feito seu exemplo, basta compactar a pasta LEDRGB_lib como .zip, abrir a IDE do Arduino, ir no menu Sketch >> Incluir Biblioteca >> Adicionar biblioteca .ZIP e selecionar o arquivo que você compactou.
Para que as cores do keywords.txt funcionem, é necessário reiniciar a IDE do Arduino.

Você ainda pode ler a API Style Guide para deixar sua biblioteca mais legível.

Para que sua biblioteca ser incluída no site do Arduino você deve ter ela no Github e abrir um issue na página do Arduino. Mas isso fica pra outro dia.

 

Qualquer dúvida estamos aqui pra ajudar!

Links
Sublime Text 2
Notepad++
API Style Guide
Library Tutorial
Libraries Guide

 

Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair /  Alterar )

Foto do Google

Você está comentando utilizando sua conta Google. Sair /  Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair /  Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair /  Alterar )

Conectando a %s