Olá tudo bem? Hoje vamos abordar a respeito de alguns comandos bastante utilizados nos códigos de nossos projetos, que são as diretivas de compilação no Arduino.
Não sabe o que elas são? Então venha comigo e vamos aprender a como utilizar essas diretivas de compilação no Arduino!
Primeiramente, muitos programadores utilizam em seus códigos, essas tais diretivas de compilação. Mas alguns deles não tem a mínima ideia, do que realmente estão fazendo com elas.
Contudo, saber qual a consequência delas em seu código é de grande importância para poder elevar muito mais o seu desenvolvimento, eficácia e manutenção do seu próprio código.
Mas por outro lado, é muito comum também que em aulas de programação em C, os professores pulem a parte de diretivas de compilação. Porém, se você quer progredir cada vez mais no ramo da programação e no estudo de firmware, você tem que conhecer as diretivas de compilação.
Diretivas de Compilação
Inicialmente, definimos as diretivas de compilação como comandos que não são compilados, ou seja, processados na compilação do código. Como assim? Eu te explico! Esses comandos são enviados ao pré-processador, o qual pode ser entendido como uma etapa anterior (pré) ao processo de compilação do código propriamente dito. Vamos explicar isso melhor!
Pré – Processador em C
Basicamente, o pré-processador em C é um programa o qual vai examinar o código criado para o Arduino e, se necessário, executar certas modificações nele. Tais modificações são baseadas nas chamadas diretivas de compilação.
Assim, o pré-processador vai modificar o nosso código escrito, mas isso vai acontecer, antes do código ser enviado ao compilador dele. Legal né? Mas lembre-se disso: todas as diretivas de compilação são iniciadas pelo caractere # (conhecido por sharp).
Além disso, essas diretivas de compilação tem apenas duas restrições: não utilizar na frente de outras diretivas e também na frente de instruções do código. O resto está valendo combinado?
Quais Diretivas de Compilação no Arduino usamos?
As duas diretivas as quais escolhi para abordar hoje com você são as seguintes:
- #include
- #define
#include
Creio que você já viu esse cara em muitos códigos por ai a fora. Então vamos começar por ele, esse comando #include é utilizado para incluir dados, seja ele um arquivo ou biblioteca.
A implementação dele em nosso código é feito para poder utilizar as variáveis, comandos e funções desses dados que ele está chamando. Vamos a um exemplo muito claro o qual utilizamos em nosso post do blog sobre servo motores:
Neste exemplo foi necessário utilizar a biblioteca do servo motor. Mas por que? Isso porque queremos utilizar os comandos existentes na biblioteca do servo. Dessa forma, vamos chamar a biblioteca escrevendo:
#include <Servo.h> // Chamando a biblioteca do servo motor
Contudo, você também pode encontrar o #include escrito dessa forma nos códigos:
#include “movimento.ino”
Mas qual a diferença?
Basicamente, a diferença entre essas duas formas de escrita é com relação ao o que você está incluindo em seu código.
- Se você quer adicionar uma biblioteca, você precisa colocar ela entre <nome_da_biblioteca.h>;
- Se você vai incluir apenas um arquivo, então basta colocar ele entre “nome_do_arquivo”.
Mas cuidado, a biblioteca que você quer adicionar, precisa estar na pasta de bibliotecas do Arduino. Já o arquivo que você quer incluir, precisa estar na pasta do código que você salvou. Fique atento a isso combinado?
#define
Abordaremos agora, a diretiva mais utilizada em diversos projetos com Arduino e afins. Isso ocorre devido a sua variedade de aplicação, podendo ela atuar de três formas:
- Como uma constante;
- Como uma macro (função) que contém parâmetros;
- Como um símbolo (constante) a ser testada.
#define como constante
Mas hoje, vamos apenas focar nas duas primeiras formas de atuação dessa função. Dessa forma, vamos aprender agora a como utilizar a diretiva #define como uma constante em nosso código. Ela é iniciada da seguinte forma:
#define nome_da_constante valor_da_constante
Como você pode observar, para utilizar essa diretiva como uma constante em nosso código, basta iniciar com # (sharp) seguindo de ‘define’, isso vale para toda vez que for utilizá-la. Logo após, colocamos o nome da variável que vai armazenar o valor que vamos alocar nessa variável.
Tudo bem, mas como implementar essa diretiva como constante em meu código? Isso é muito simples, observe o código abaixo e veja um exemplo de sua utilização:
#define Pin 10 // Declarando a constante 'Pin' com o valor 10
// Que na verdade é o valor do pino que o led esta
void setup()
{
pinMode(Pin, OUTPUT); // Aqui não precisa colocar o valor do LED só
// o nome da constante que ele esta associado
}
void loop()
{
digitalWrite(Pin, HIGH);
delay(500);
digitalWrite(Pin, LOW);
delay(500);
}
#define como macro que possui parâmetros
Como já falado, a diretiva #define pode também atuar como uma macro para parâmetros. Isso é simplesmente uma função que está embutido no código mas é definida bem no começo. Ela é definida da seguinte forma:
#define nome_da_função(parâmetros) expressão_de_substituição
Então vamos lá, primeiro vamos iniciar a diretiva #define e logo em seguida, vamos colocar o nome da função que iremos criar. Na frente dessa função, iremos colocar os parâmetros entre parênteses, esses parâmetros são variáveis as quais serão utilizadas na “expressão_de_substituição”.
Ou seja, vamos ter um número X de variáveis no campo ‘parâmetros’ as quais iremos dar valores a elas durante o código. Em seguida, na expressão de substituição, vamos manusear essas variáveis e resultado dessa expressão, é retornado para a função. Observe o exemplo abaixo:
#define tempo(a) (a/2) //Função criada para o controle do delay
// Quando a função receber um valor no lugar de 'a'
// Ela vai dividir por 2 e voltar o resultado na função
//--------------------------------------------------------------
#define Pin 10 // Declarando a constante 'Pin' com o valor 10
// Que na verdade é o valor do pino que o led esta
//--------------------------------------------------------
void setup()
{
pinMode(Pin, OUTPUT); // Aqui não precisa colocar o valor do LED só
// o nome da constante que ele esta associado
}
void loop()
{
digitalWrite(Pin, HIGH);
delay(tempo(1000));
digitalWrite(Pin, LOW);
delay(tempo(1000));
}
Por hoje foi isso, espero que você tenha adquirido maior conhecimento em programação ou tenha tirado maiores dúvidas a respeito das diretivas de compilação. Nos próximos posts estarei abordando maiores tópicos sobre programação combinado?
Mas e ai? Gostou? Caso tenha ficado algo incompleto para você, deixe seu comentário 
Dicas? 
Forte abraço!