Conceitos Básicos de Programação
Vamos explorar os fundamentos da linguagem utilizada para programar o Arduino. Se você já está familiarizado com alguma linguagem de programação, pode simplesmente realizar uma adaptação para este novo ambiente.
Vamos explorar os fundamentos da linguagem utilizada para programar o Arduino. Se você já está familiarizado com alguma linguagem de programação, pode simplesmente realizar uma adaptação para este novo ambiente.
Declaramos como constante um objeto cujo valor não precisa ser modificado durante todo o processamento, mantendo-se inalterado do início ao fim da execução.
Existem duas formas de declarar uma constante:
Utilizando a palavra reservada CONST. Exemplo: const int LED = 10;
Utilizando a palavra reservada DEFINE. Exemplo: #define PINO_A 10
Ambas as formas garantem que o valor atribuído à constante não será alterado durante a execução do programa.
Em todas as linguagens de programação, existem palavras reservadas que têm significados específicos. Em C++, algumas dessas palavras incluem:
TRUE – Indica um valor lógico verdadeiro;
FALSE – Indica um valor lógico falso;
HIGH – Indica que uma porta está ativada, ou seja, com 5V;
LOW – Indica que uma porta está desativada, ou seja, com 0V;
INPUT – Indica que uma porta será utilizada como entrada de dados;
OUTPUT – Indica que uma porta será utilizada como saída de dados.
Essas palavras reservadas têm papéis específicos na programação em C++, ajudando a controlar e definir o comportamento de variáveis, portas e operações lógicas.
As variáveis são objetos que armazenam (posição de memória) dados e seu conteúdo pode variar durante o processamento. Uma variável só pode armazenar um único valor por vez.
Sua declaração é formada por um ou mais caracteres, em que o primeiro caractere é uma letra.
Não é permitido nem para uma constante ou variável, identificadores com caracteres especiais (*, %, @, etc), palavras reservadas ou espaços em branco. Se preferir, poderá utilizar o underline (“_”).
Exemplo:
executar_Led = false;
Variáveis e Constantes
A seguir os tipos de variáveis existentes:
bool - Os valores possíveis são true (1) e false (0). Ocupa um byte de memória.
exemplo: bool executar = false;
char - Pode ser uma letra ou um número. A faixa de valores válidos é de -128 a 127. Ocupa um byte de memória.
exemplo: char caractereA = 65; ou char led = ‘L’;
unsigned char - Semelhante ao char, porém a faixa de valores válidos é de 0 a 255. Ocupa um byte de memória.
exemplo: unsigned char novoChar = 240;
byte - A faixa de valores é de 0 a 255. Ocupa 1 byte de memória.
exemplo: byte b = B10010; // B10010 = 18 decimal;
Int - Armazena números inteiros e ocupa 16 bits de memória (2 bytes). A faixa de valores é de -32.768 a 32.767.
exemplo: int ledPino = 10;
unsigned int - Semelhante ao int, porém a faixa de valores válidos é de 0 a 65.535. Ocupa 2 bytes de memória.
exemplo: unsigned ledPino = 10;
word - Semelhante ao unsigned int.
exemplo: word x = 1000;
long - Armazena números de até 32 bits (4 bytes). A faixa de valores é de -2.147.483.648 até 2.147.483.647.
exemplo: long velocidade = 186000;
unsigned long - Semelhante ao long, porém a faixa de valores é de 0 até 4.294.967.295.
exemplo: unsigned long time;
short - Armazena número de até 16 bits (2 bytes). A faixa de valores é de -32.768 até 32.767.
exemplo: short ledPino = 10;
float - Armazena valores de ponto flutuante (com vírgula) e ocupa 32 bits (4 bytes) de memória. A faixa de valores é de -3.4028235E+38 até 3.4028235E+38.
exemplo: float sensorCalibrado = 1.117;
double - Semelhante ao float.
exemplo: double sensorCalibrado = 1.117;
String – Ocupa 1 byte por caractere +bytes adicionais para metadados. Utilizado para coleção de caracteres.
Array - Ocupa 1 byte por elemento. Utilizado para coleção de variáveis do mesmo tipo.
Tipos de Variáveis
A atribuição de valores para as variáveis e constantes são realizados com o uso do operador =.
Exemplos:
int efeito = 3;
int contraste = 0;
boolean aumenta = true;
Observações:
O Operador de atribuição não é utilizado com o comando #define;
A linguagem de programação do Arduino é Case Sensitive, diferenciando letras maiúsculas de minúsculas. Portanto a declaração int efeito é diferente de int Efeito.
Declaração de Variáveis
Vetores e Matrizes
Uma variável pode armazenar muitos valores ao longo da execução do programa, porém não ao mesmo tempo. Entretanto, existem alguns tipos de variáveis que podem armazenar mais de um valor, são conhecidas como “variáveis vetoriais”. Na programação do Arduino é possível utilizar dois tipos de “variáveis vetoriais”: Vetores e Matrizes.
Para declarar um vetor é necessário definir o tipo e o tamanho (quantidade de itens). Um vetor é unidimensional, ou seja, uma única dimensão.
Exemplo: Criar um vetor de tamanho 3 (três) do tipo inteiro.
int pinLed[3] = {2,3,4};
Para atribuir um valor a uma determinada posição do vetor, basta usar o índice, ou seja, a posição onde o valor será armazenado no vetor, lembrando que a primeira posição do vetor é a posição 0 (zero).
Exemplo: Atribuir o valor 2 (dois) para a posição 0 (zero) do vetor:
pinLed[0] = 2;
Para acessar um valor em uma determinada posição do vetor, basta indicar a sua localização (índice).
Exemplo:
pinMode(pinLed[0], OUTPUT);
Vetores
Vetores de Strings
Quando for trabalhar com vários textos, podemos utilizar um vetor de strings.
O asterisco indica que se trata de um vetor de string.
Exemplo:
Uma matriz é similar a um vetor, porém pode ser formada por duas ou mais dimensões, ou seja, é bidimensional. Este elemento possui um determinado número de linhas e de colunas.
Exemplo: Criar uma matriz 4x4 de char.
Matrizes
Para atribuir um valor a uma determinada posição da matriz, basta usar o índice (linha e coluna).
Exemplo: Atribuir o valor A para a posição 1 (linha), 4 (coluna) da matriz teclas:
teclas [0] [3] = 'A';
Para acessar um determinado valor em uma posição da matriz, basta usar o índice (linha e coluna).
Exemplo: Ativar a porta 0 (linha), 0 (coluna) da matriz teclas:
digitalWrite(teclas[0][0],HIGH);
Aqui está um exemplo completo demonstrando como declarar, inicializar e acessar elementos de uma matriz no Arduino:
Além dos dados existentes em um processamento de um programa, temos também os operadores que são elementos que indicam a realização de uma operação sobre esses tipos de dados, gerando um resultado. O termo operador é o elemento que indica a realização da operação.
Operadores
Os operadores aritméticos são utilizados nos cálculos matemáticos, são os responsáveis pelas operações matemáticas realizadas no computador. No próximo quadro (Quadro FR1), iremos mostrar como utilizar os operadores e o grau de prioridade em um cálculo matemático.
Operadores Aritméticos
Quadro FR1 - Operadores Aritméticos
Quadro FR2 - Operadores Relacionais
Os operadores relacionais (Quadro FR2) permitem que sejam feitas comparações entre dois elementos, tendo como resultado um valor lógico (Verdadeiro ou Falso). Através do resultado da comparação, é possível determinar qual caminho um processamento vai seguir. Os operadores relacionais possuem o mesmo grau de prioridade entre si.
Operadores Relacionais
Quadro FR3 - Operadores Relacionais
Da mesma forma que os operadores relacionais (Quadro FR3), os operadores lógicos retornam como resultado um dos dois valores lógicos: verdadeiro ou falso.
Os operadores lógicos podem ser: conjunção (AND); disjunção (OR); e negação (NOT).
Operadores Lógicos
Operadores Lógicos de conjunção
A conjunção é uma operação lógica que relaciona dois valores lógicos (Quadro FR4) através do operador &&.
Para que o resultado lógico de saída seja verdadeiro, é necessário que os valores lógicos de entrada sejam verdadeiros.
Quadro FR4 - Operador Lógico de Conjunção
Quadro FR5 -Operador Lógico de Disjunção
A disjunção é uma operação lógica que relaciona dois valores lógicos (Quadro FR5) através do operador ||.
Para que o resultado lógico de saída seja verdadeiro, é necessário que pelo menos um dos valores lógicos de entrada seja verdadeiro.
Operadores Lógicos de Disjunção
Exemplo:
if (x==2 && y==10) {......}
Essa expressão retornará verdadeiro se ambos os operandos forem verdadeiros, ou seja, x deverá ser igual a 2 e y deverá ser igual 10, caso contrário retornará falso.
Exemplo:
if (x==2 || y==10) {......}
Essa expressão retornará verdadeiro se um ou mais operandos forem verdadeiros, ou seja, x deverá ser igual a 2 ou y deverá ser igual 10, caso contrário retornará falso.
Negação é uma operação lógica que gera como saída um valor lógico inverso ao valor lógico de entrada (Quadro FR6). É utilizado o operador !.
Operadores Lógicos de Negação
Quadro FR6 - Operador Lógico de Negação
Exemplo:
if (!x) {......}
Essa expressão retornará verdadeiro se o operando for falso, ou seja, x deverá ser igual a 0, caso contrário retornará falso.
As condições podem aparecer “aninhadas”.
Exemplo:
if (x==2 || y==10 && k == 20) {......}
Grau de Prioridades
Os operadores lógicos possuem o seguinte nível de prioridade entre os operadores que devem ser obedecidas (Quadro FR7).
Quadro FR7 - Grau de Prioridade entre Operadores Lógicos
Se for necessário alterar a ordem de prioridade em um processamento lógico específico, deve-se utilizar parênteses. É importante lembrar que os cálculos são realizados da esquerda para a direita, a menos que parênteses sejam usados para modificar essa ordem.
Exemplo:
if ( x==2 && (y==10 || k == 20) ) {......}
é diferente de:
if ( x==2 && y==10 || k == 20 ) {......}
Funções
No Arduino é possível controlar o intervalo de execução dos componentes através das Funções.
Função delay():
A função delay() é a maneira mais simples de temporizar no Arduino. Ela suspende a execução do programa por um período específico em milissegundos (ms). Durante esse tempo, o Arduino não executa nenhuma outra instrução
Exemplo: delay(1000); // Aguarda 1 segundo (1000 milissegundos)
Funções de Temporização
Função millis() para temporizações não bloqueantes:
A função millis() retorna o tempo em milissegundos desde que o Arduino foi iniciado. É útil para criar temporizações não bloqueantes usando comparações de tempo.
Exemplo:
unsigned long tempoInicial = millis();
while (millis() - tempoInicial < 5000) {
// Executa alguma ação por 5 segundos
}
Neste exemplo, o loop executa uma ação durante aproximadamente 5 segundos, mas permite que outras operações continuem enquanto espera.
Interrupções de tempo:
Para tarefas que exigem precisão ou necessitam de execução em momentos específicos, as interrupções de tempo usando Timer ou TimerOne (bibliotecas Timer) podem ser utilizadas. Isso permite a execução de código em intervalos precisos, mesmo enquanto outras operações estão em andamento.
Exemplo
#include <TimerOne.h>
void setup() {
Timer1.initialize(1000000); // Configura temporização para 1 segundo (em microssegundos)
Timer1.attachInterrupt(timerCallback); // Chama a função timerCallback a cada segundo
}
void loop() {
// Outras operações aqui
}
void timerCallback() {
// Código a ser executado a cada segundo
}
As funções matemáticas podem ser usadas para realizar cálculos comuns.
Funções Matemáticas
Funções Trigonométricas:
sin(x): Calcula o seno de x (onde x está em radianos).
cos(x): Calcula o cosseno de x (onde x está em radianos).
tan(x): Calcula a tangente de x (onde x está em radianos).
Exemplo:
float seno = sin(3.14159 / 2); // Aproximadamente 1.0
float cosseno = cos(0); // Aproximadamente 1.0
float tangente = tan(3.14159 / 4); // Aproximadamente 1.0
Funções de Potência e Raiz:
pow(base, expoente): Calcula a base elevada ao expoente.
sqrt(x): Calcula a raiz quadrada de x.
Exemplos:
float potencia = pow(2, 3); // 2^3 = 8
float raiz = sqrt(16); // √16 = 4
Funções Exponenciais e Logarítmicas:
exp(x): Calcula e elevado à potência x.
log(x): Calcula o logaritmo natural (base e) de x.
log10(x): Calcula o logaritmo de base 10 de x.
Exemplos:
float exponencial = exp(1); // e^1 ≈ 2.71828
float logaritmo = log(2.71828); // ln(e) ≈ 1
float logaritmo10 = log10(100); // log10(100) = 2
Funções de Arredondamento e Valor Absoluto:
abs(x): Calcula o valor absoluto de x.
ceil(x): Arredonda x para cima (próximo inteiro).
floor(x): Arredonda x para baixo (próximo inteiro).
round(x): Arredonda x para o inteiro mais próximo.
Exemplos:
int valorAbsoluto = abs(-5); // 5
float arredondaCima = ceil(2.3); // 3.0
float arredondaBaixo = floor(2.7); // 2.0
float arredonda = round(2.5); // 3.0
Funções Aleatórias:
randomSeed(seed): Inicializa o gerador de números aleatórios com um valor de semente.
random(max): Gera um número aleatório entre 0 e max-1.
random(min, max): Gera um número aleatório entre min e max-1.
Exemplos:
void setup() {
randomSeed(analogRead(0)); // Inicializa a semente com a leitura de um pino analógico
}
void loop() {
int aleatorio1 = random(10); // Número aleatório entre 0 e 9
int aleatorio2 = random(5, 15); // Número aleatório entre 5 e 14
}
Função map():
A função map() no Arduino é usada para reescalar um número de um intervalo para outro. Isso pode ser particularmente útil quando você está trabalhando com entradas e saídas analógicas ou digitais, onde você precisa converter um valor de um intervalo para outro.
A função map() tem a seguinte assinatura:
long map(long x, long in_min, long in_max, long out_min, long out_max);
Ela mapeia o valor x do intervalo [in_min, in_max] para o intervalo [out_min, out_max].
Exemplo:
Imagine que você está lendo um valor de um sensor de luz que retorna valores entre 0 e 1023 (intervalo típico de leitura analógica no Arduino), mas você quer converter esses valores para um intervalo de 0 a 255 (intervalo típico de PWM para controlar a intensidade de um LED). Você pode usar a função map() para fazer essa conversão.
void setup() {
Serial.begin(9600);
}
void loop() {
int sensorValue = analogRead(A0); // Lê o valor do sensor de luz
int outputValue = map(sensorValue, 0, 1023, 0, 255); // Converte para o intervalo 0-255
analogWrite(9, outputValue); // Define a intensidade do LED conectado ao pino 9
Serial.print("Sensor Value: ");
Serial.print(sensorValue);
Serial.print(" Mapped Value: ");
Serial.println(outputValue);
delay(1000); // Espera 1 segundo
}
Funções Caracteres
No Arduino, existem várias funções para manipulação de caracteres e strings. Estas funções são úteis quando você precisa lidar com dados de texto, como leitura de entradas de usuário, comunicação serial, e manipulação de mensagens.
isAlpha(char c):
Verifica se o caractere c é uma letra (A-Z ou a-z).
Exemplo:
if (isAlpha('A')) {
// True, 'A' é uma letra
}
isDigit(char c):
Verifica se o caractere c é um dígito (0-9).
Exemplo:
if (isDigit('3')) {
// True, '3' é um dígito
}
isAlnum(char c):
Verifica se o caractere c é alfanumérico (letra ou dígito).
Exemplo:
if (isAlnum('a')) {
// True, 'a' é alfanumérico
}
Funções para Strings (Classe String)
Exemplo completo:
void setup() {
Serial.begin(9600);
String texto = " Arduino ";
// Funções de manipulação de caracteres
char c = 'a';
if (isAlpha(c)) {
Serial.println("É uma letra.");
}
// Funções de manipulação de strings
int comprimento = texto.length();
Serial.print("Comprimento: ");
Serial.println(comprimento);
String textoTrim = texto.trim();
Serial.print("Trim: ");
Serial.println(textoTrim);
String upper = textoTrim.toUpperCase();
Serial.print("Uppercase: ");
Serial.println(upper);
String sub = textoTrim.substring(1, 4);
Serial.print("Substring: ");
Serial.println(sub);
int pos = textoTrim.indexOf('d');
Serial.print("Posição de 'd': ");
Serial.println(pos);
}
void loop() {
// Código vazio
}
<<<Pesquisar: funções de Conversão>>>
Geralmente é necessário comentar as linhas dos códigos de um programa.
Utilizaremos duas maneiras:
Comentário de linha: //.
Comentário de bloco: /* */, utilizado para comentar mais de uma linha.
Exemplo:
Comentários
int ledPin = 13; // Define o pino 13 como o pino do LED
/*
A função setup é executada uma vez quando o programa inicia.
Aqui, configuramos o pino do LED como saída.
*/
void setup() {
pinMode(ledPin, OUTPUT); // Configura o pino do LED como saída
}
/*
A função loop é executada repetidamente.
Acende o LED, aguarda por 1 segundo,
apaga o LED, e aguarda por mais 1 segundo.
*/
void loop() {
digitalWrite(ledPin, HIGH); // Acende o LED
delay(1000); // Aguarda por 1 segundo
digitalWrite(ledPin, LOW); // Apaga o LED
delay(1000); // Aguarda por 1 segundo
}