Comandos Básicos da Arduino IDE

Introdução

A programação na IDE do Arduino conta com diversos comandos importantes para a implementação do seu código. Dentre elas, existem algumas funções fundamentais que serão utilizadas desde o projeto mais básico até o mais avançado. 

Na imagem a seguir você pode conferir essas funções e suas categorias: No post de hoje falaremos um pouco sobre cada uma dessas funções e apresentaremos a sintaxe correta de cada uma, para auxiliar em seu aprendizado na programação do Arduino. Veja só:

Funções Nativas

void setup( ){ }

Essa é a primeira função a ser executada após a energização do Arduino e o código dentro dela será executado apenas uma vez. Dentro do setup devemos inserir toda a configuração lógica do código, como atribuição de entradas e saídas, inicialização da comunicação serial, etc.

void loop( ){ }

O loop() vem logo após a função setup e é onde toda a lógica do código que deverá ser executado está contida. O código que está dentro da função loop() será executado continuamente enquanto o Arduino estiver energizado.

Funções setup() e loop() em um sketch em branco da Arduino IDE 

Entrada e Saída de Sinais

pinMode( )

O comando pinMode() é responsável por atribuir uma funcionalidade ao pino do Arduino. Através dessa função, definimos qual pino será usado e se irá trabalhar como entrada (INPUT) ou saída (OUTPUT) e deve ser definido dentro da função setup( ). Veja a sintaxe abaixo:

void setup(){
pinMode(2, OUTPUT);   //pino 2 do Arduino setado como SAÍDA
pinMode(3, INPUT);    //pino 3 do Arduino setado como ENTRADA
pinMode(4, INPUT_PULLUP);   //pino 4 do Arduino setado como ENTRADA com resistor de pull up.
}

Além dos citados acima, pode ser visto também que existe o modo INPUT_PULLUP, que permite acionar um resistor interno do Arduino para aplicações onde o pino setado trabalha como entrada, lendo o sinal enviado por um botão, por exemplo.

digitalRead( )

Esse comando é responsável por ler o estado de porta digital que está trabalhando como entrada (INPUT), identificando se o dispositivo conectado a ela está enviando um sinal em nível lógico HIGH (5V) ou LOW (0V). Abaixo você pode ver a sintaxe correta do comando:

void loop(){ 
int var = digitalRead(3); //Lê a entrada do pino 3 e armazena o valor na variável do tipo inteira "var"
}

digitalWrite( )

Esse comando é responsável por alterar o estado em uma porta digital que trabalha como saída (OUTPUT) para HIGH (5v) ou LOW (0v). É utilizado para enviar sinais e acionar componentes, como ligar um led. Veja a sintaxe abaixo:

void loop(){
digitalWrite(2, LOW);// faz com que o pino 2 fique no estado LOW (0v)
digitalWrite(1, HIGH);// faz com que o pino 1 fique no estado HIGH (5v)
}

analogRead( )

O comando analogRead( ) faz a leitura dos sinais enviados à uma porta analógica, retornando um valor entre 0 (0V) e 1023 (5V). Veja a sintaxe abaixo:

void loop(){
analogRead(A0); //Lê a entrada do pino analógico A0
}

analogWrite( )

Esse comando se encarrega de enviar um sinal PWM em uma porta compatível, sendo seu valor entre 0 (0V) e 255 (5V). Com o comando analogWrite conseguimos controlar a potência de diversas cargas, como a intensidade de brilho de um LED, por exemplo. Veja a sintaxe abaixo:

void loop(){ 
analogWrite(A0, 0);// faz com que o pino A0 fique com valor 0 (0v) 
analogWrite(A1, 255);// faz com que o pino A1 fique com valor 255 (5v) 
}

Funções de Tempo

delay( ):

O comando delay() é uma função de tempo utilizada para parar ou atrasar a execução do código por um período determinado de tempo. É expresso em milissegundos (1/1.000 segundo) e uma de suas vantagens está em iniciar a contagem de tempo a partir do momento em o comando é interpretado e processado. Sua maior desvantagem é o fato de "travar" o Arduino durante sua execução, já que nesse período de tempo o microcontrolador não consegue ler nenhum dado ou executar nenhuma outra tarefa. Veja a sintaxe abaixo:

void loop(){ 
delay(1000); //congela o código por 1000 milissegundos
}

delayMicroseconds( ):

Esse comando tem as mesmas características do anterior (delay()), porém se difere na unidade de tempo a ser executada, que nesse caso é o microssegundo (1/1.000.000 segundo, ou 1/1.000 milissegundo). Confira a sintaxe do comando abaixo:

void loop(){ 
delayMicroseconds(1000); //congela o código por 1000 microssegundos, ou 1 milissegundo
}

millis( ):

A função millis() também é uma função de tempo com contagem em milissegundos, porém se difere da função delay() por ser iniciada assim que o Arduino é energizado, independente de estar no código ou não. Essa característica permite que o microcontrolador execute tarefas em paralelo à contagem de tempo, simulando uma espécie de multitarefas, sem congelar o código como os demais comandos de tempo. Para chamar a função, é necessário atribuir previamente o valor de millis() à uma variável e diminuir o valor contido nela o valor atual de millis() e, em seguida, comparar essa diferença com o intervalo de tempo que desejamos aguardar. Confira sua sintaxe e a lógica descrita acima no seguinte exemplo:

void loop(){
var = millis(); //atribui o valor de millis à variável "var"

if((millis()-var)>2000){  //verifica se millis() atual subtraindo o valor armazenado em var é menor que 2000
 
 var = millis();  //renova o valor de millis() em var
 }
}

Importante: após aproximadamente 50 dias, a função sofre overflow (chega ao seu valor máximo) e então volta ao valor zero.

micros( ):

A função micros() executa as mesmas tarefas da função millis(), porém é expressa em microssegundos. Sua diferença está no tempo de overflow: leva aproximadamente 70 minutos para a função chegar ao valor máximo de armazenamento. Veja a sintaxe abaixo:

void loop(){

 var = micros(); //atribui o valor de millis à variável "var"

if((micros()-var)>2000){  //verifica se millis() atual subtraindo o valor armazenado em var é menor que 2000
 
 var = micros();  //renova o valor de millis() em var
 }
}

Funções Matemáticas

abs( ):

Retorna o módulo (valor absoluto) de um número. Veja a sintaxe abaixo:

void loop(){ 
var = abs(x); //atribui o módulo de x a variável "var"
}

map( ):

A função map() é responsável por converter o valor de um intervalo em um intervalo diferente. É muito utilizado em aplicações onde uma entrada analógica controla uma saída digital, como um potenciômetro controlando o brilho de um led, por exemplo. Veja a sintaxe abaixo:

void loop(){
sinal = analogRead(x); //lê uma entrada analógica x e armazena o valor na variável "sinal" 
var = map(x, deMin, deMax, paraMin, paraMax); //remapeia os mínimos e máximos contidos em x para outro intervalo
}

max( ):

Retorna o  maior entre dois valores. Veja a sintaxe abaixo:

void loop(){
var = max(x, y); // retorna o valor do maior entre x e y
}

min( ):

Retorna o menor entre dois valores. Veja a sintaxe abaixo:

void loop(){ 
var = min(x, y); // retorna o valor do menor entre dois valores x e y 
}

sqrt( ):

Retorna a raiz quadrada de um número. Veja a sintaxe abaixo:

void loop(){ 
var = sqrt(x); // atribui a var a raiz quadrada de um número x
}

Funções de Números Aleatórios

random:

Essa função é responsável por retornar números pseudo-aleatórios, ou seja, números que dependem de algum valor pré-definido para serem gerados. No caso dessa função, esses números são gerados dentro de um determinado intervalo de valores. Confira abaixo a sintaxe da função:

void loop(){ 
int var = random(min, max);); // retorna um valor aleatório entre min e max e armazena na variável do tipo inteira nomeada "var".
}

Conclusão

O post de hoje trouxe um assunto mais teórico, porém muito útil para todos nós que utilizamos a Arduino IDE para escrever nossos códigos. Esperamos que esse post tenha contribuído para seu aprendizado e se ficou alguma dúvida, deixe nos comentários. Um forte abraço e até a próxima. Conheça a Metodologia Eletrogate e ofereça aulas de robótica em sua escola!

Sobre o Autor

Caio Teraoka Estudante de engenharia elétrica e entusiasta na área da robótica e microcontroladores.