Noções básicas de C++ em um Arduino, Parte 5: Bibliotecas de software e classes personalizadas

Este Noções básicas de C++ em uma série Arduino cobre muitos elementos diferentes necessários para todos os tipos de projetos e ideias em um Arduino. Nesta entrada, cobrimos a importação de bibliotecas de software externas para o Arduino IDE para que você possa usá-las em seus projetos.

Carregando bibliotecas externas

Conectar módulos externos e outros dispositivos ao seu Arduino é algo comum de se fazer. Freqüentemente, isso exigirá que você carregue bibliotecas de software adicionais para fazer a interface dos componentes externos. Uma maneira de fazer isso é usar o gerenciador de biblioteca do Arduino IDE:

Assim que a janela de diálogo aparecer, pesquise a biblioteca que deseja baixar e clique no botão de instalação assim que a encontrar:

Assim que a instalação terminar, você pode usar a barra de menu principal do IDE para incluir qualquer biblioteca instalada:

Observe que, embora você encontre muitas bibliotecas aqui, às vezes uma instalação manual é necessária. Se for esse o caso do seu componente, consulte o manual ou a folha de dados do dispositivo.

Crie classes C++ personalizadas

Uma classe C++ é uma coleção de variáveis e funções associadas que são definidas em um lugar. Eles tornam seu código mais fácil de ler, manter e entender. Além disso, você pode compartilhar suas aulas personalizadas com outras pessoas. Seu conteúdo pode ser público, o que significa que eles são expostos ao exterior, por exemplo, outros programas, ou você pode torná-los privados para restringir o acesso a eles.

Cada classe precisa de pelo menos um construtor, que é uma função especial que tem o mesmo nome da classe e nenhum tipo de retorno (nem mesmo void). Uma classe também pode definir vários construtores com parâmetros diferentes.

Você deve se lembrar dos arquivos de cabeçalho, que foram abordados anteriormente na série. Você precisará de um para definir o conteúdo da sua aula. Observe que o arquivo de cabeçalho contém apenas as definições, não a implementação concreta, que ainda reside em um arquivo cpp separado.

Isso pode ser melhor explicado com um exemplo. Primeiro, o arquivo de cabeçalho:

// Arquivo: Truck.h
// Essas declarações são opcionais. No entanto, eu recomendo que você os adicione porque
// eles impedirão que o código da biblioteca seja importado várias vezes.
#ifndef Truck_h
#define Truck_h

// Você precisa importar Arduino.h para escrever uma biblioteca personalizada
#include "Arduino.h"

class Truck
{
  public:
    // Um ou mais construtores (dois neste exemplo)
    Truck(int hp, int torque, int axles, String manufacturer);
    Truck(int hp, String make, String model);
    // Quatro métodos públicos
    void drive(String from, String to);
    void load(String goods, int amount);
    void unload(String goods, int amount);
    void unloadAll(void);
    // Uma função estática
    static float barToPsi(float bar);
  private:
    // Três variáveis de string privadas
    String currentLocation, make, model;
    // E três inteiros privados
    int hp, torque, axles;
};

#endif

Conforme mencionado, o arquivo de cabeçalho consiste em uma listagem do que a classe contém. A implementação dos métodos é feita no arquivo cpp:

// Arquivo: Truck.cpp
// Importe seu arquivo de cabeçalho personalizado e o arquivo de cabeçalho do Arduino
#include "Truck.h"
#include "Arduino.h"

// Em seguida, defina todas as funções e implemente suas funcionalidades

Truck::Truck(int hp, int torque, int axles, String manufacturer)
{
    // Faça alguma coisa
}

Truck::Truck(int hp, String make, String model)
{
    Truck::hp = hp;
    Truck::torque = 2400;
    Truck::axles = 6;
    Truck::make = make;
    Truck::model = model;
}

void Truck::drive(String from, String to)
{
    // Faça alguma coisa
}

void Truck::load(String goods, int amount)
{
    // Faça alguma coisa
}

void Truck::unload(String goods, int amount)
{
    // Faça alguma coisa
}

void Truck::unloadAll(void)
{
    // Faça alguma coisa
}

float Truck::barToPsi(float bar)
{
    return bar * 14.504f;
}

Como você pode ver, o arquivo cpp contém todos os métodos do arquivo de cabeçalho. Observe como todos os métodos têm Truck :: antes de seus nomes. Isso indica que uma função ou variável faz parte da classe Truck.

Importando uma Biblioteca Personalizada

Aqui, você tem duas opções. Você pode copiar e colar os arquivos cpp e header na pasta em que seu esboço reside. Isso nem sempre é uma abordagem recomendada, pois será difícil manter o controle de suas bibliotecas. Em vez disso, é melhor criar uma nova pasta dentro da pasta da biblioteca do Arduino e mover os arquivos para lá:

Em seguida, você encontrará sua biblioteca personalizada na barra de cabeçalho superior, juntamente com todas as outras bibliotecas instaladas:

Usando sua classe personalizada

Para usar a biblioteca recém-criada, você primeiro terá que importá-la para um esboço do Arduino. Você terá então que criar uma nova instância da classe Truck usando um dos construtores antes de poder chamar uma função.

Observe que também é possível criar funções estáticas que não pertencerão a um objeto. Em vez disso, todas as instâncias de uma classe compartilharão o mesmo método. Nesse caso, você chama o método usando o nome da classe:

// Importe seu módulo personalizado
#include <Truck.h>

// Cria uma nova instância da classe Truck
Truck t = Truck(600, "Trucker", "120-deluxe");

void setup()
{
  // Chamar métodos que foram definidos no módulo Truck
  t.load("Canned Corn", 20);
  t.load("Bread", 5);

  Serial.begin(9600);
}

void loop()
{
  float bar = 20;
  // Chame uma função estática que pertença a toda a classe
  // em vez de uma instância concreta da classe
  float psi = Truck::barToPsi(20);

  Serial.print(bar);
  Serial.print(" bar in PSI: ");
  Serial.println(psi);

  delay(10000);
}

Resumo

As classes são úteis para agrupar comportamentos e variáveis semelhantes. Eles permitem que você torne seu código mais legível e fácil de entender. Além disso, você pode compartilhar suas bibliotecas personalizadas com outras pessoas. As classes podem expor métodos e variáveis ao público ou ocultar detalhes. Em C++, as classes consistem em um arquivo de cabeçalho, que contém as declarações, e um arquivo cpp com a implementação concreta