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ó:
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.
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
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.
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" }
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) }
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 }
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) }
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 }
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 }
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.
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 } }
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" }
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 }
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 }
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 }
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 }
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". }
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!
|
A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.
Conheça a Metodologia Eletrogate e Lecione um Curso de Robótica nas Escolas da sua Região!