Gerador de gráficos de funções lineares e quadráticas com Arduino

Funções:

Funções são relações entre dois conjuntos, onde a cada elemento do primeiro conjunto (domínio) é associado exatamente um elemento do segundo conjunto (imagem). Elas são usadas para descrever fenômenos matemáticos, científicos e do cotidiano, como o crescimento populacional ou a parábola da trajetória de lançamento de um objeto.

Como funcionam

Uma função é geralmente representada como f(x), onde x é a variável independente, e f(x) é o valor associado a x. Por exemplo, f(x) = 2x + 3 associa cada valor de x a um valor correspondente obtido pela fórmula.

Tipos de funções

1. Função linear: Tem a forma geral f(x) = ax + b, onde a e b são constantes. O gráfico é uma linha reta, e a representa a inclinação da reta.
2. Função quadrática: Tem a forma f(x) = ax^2 + bx + c, onde a, b, e c são constantes. O gráfico é uma parábola.

Parábolas

As parábolas são os gráficos de funções quadráticas. Elas podem ser voltadas para cima (se a > 0) ou para baixo (se a < 0), e o ponto mais baixo (ou mais alto) da parábola é chamado de vértice. Elas são simétricas em relação a um eixo vertical que passa pelo vértice.

Introdução ao projeto

A seguir, iremos montar um projeto gerador de gráficos de funções lineares e quadráticas com Arduino. Esse projeto permite que o usuário insira os coeficientes de equações de 1º ou 2º grau através do monitor serial do Arduino e escolha o intervalo de x, assim os resultados dessas funções serão calculados e exibidos. Além disso, LEDs serão usados para indicar se a função é crescente ou decrescente, proporcionando uma indicação visual interativa.

O Hardware:

Materiais necessários para montar o circuito:

• 1x Uno R3 + Cabo Usb para Arduino
• 1x Protoboard 400 Pontos
• 1x Led Difuso 5mm Vermelho
• 1x Led Difuso 5mm Amarelo
• 1x Jumpers – Macho/Macho – 40 Unidades de 20cm
• 1x Resistor 330K 1/4W (10 Unidades)

Diagrama de Ligação:

Conexão os LEDs:

• LED Vermelho (para indicar valores negativos de ‘a’):
  • O pino positivo (anodo) do LED vermelho deve ser conectado ao pino 7 do Arduino.
  • O pino negativo (catodo) do LED vermelho deve ser conectado a um resistor de 330Ω.
  • O outro terminal do resistor deve ser conectado ao GND (terra) do Arduino.
  • Use jumpers para auxiliar as conexões.
• LED Amarelo(ou outro LED para valores positivos de ‘a’):
  • O pino positivo (anodo) do LED Amarelo deve ser conectado ao pino 8 do Arduino.
  • O pino negativo (catodo) deve ser conectado a um resistor de 330Ω.
  • O outro terminal do resistor deve ser conectado ao GND do Arduino.
  • Use jumpers para auxiliar as conexões.

O software:

Código:

//Criado por Daniel Vasconcelos
#include <SoftwareSerial.h>  // Biblioteca para comunicação serial com outro dispositivo (não usada diretamente no código)
int i;       // Declaração de uma variável inteira 'i', usada para iterar no loop
float num;   // Declaração de uma variável de ponto flutuante 'num', que armazenará os resultados das funções
float xi;    // Variável de ponto flutuante 'xi', que define o valor inicial do intervalo de x
float xf;    // Variável de ponto flutuante 'xf', que define o valor final do intervalo de x
float xa;    // Variável de ponto flutuante 'xa', que define o incremento para iteração de x
float a;     // Variável de ponto flutuante 'a', que configura o coeficiente a
float c;     // Variável de ponto flutuante 'c', que configura o coeficiente c
float b;     // Variável de ponto flutuante 'b', que configura o coeficiente b
// Setup inicial: Este bloco é executado apenas uma vez quando o programa começa
void setup() {
  Serial.begin(31250);   // Inicializa a comunicação serial a 9600 bps (bits por segundo)
  pinMode(7, OUTPUT);   // Define o pino 7 como saída (controlará o LED vermelho)
  pinMode(8, OUTPUT);   // Define o pino 8 como saída (controlará o LED amarelo)
  delay(1000);          // Espera 1 segundo para garantir que tudo esteja inicializado corretamente
  Serial.println("digite start para exibir o gráfico de equações de 1º grau, digite start2 para funções de 2º grau");//imprime no monitor serial 
  // Exibe a mensagem no monitor serial para o usuário
}

// Função auxiliar para verificar o valor de 'a' e acionar os LEDs
void verify(){
  if (a < 0 ){               // Se 'a' for negativo,
    digitalWrite(7, HIGH);   //Liga o LED vermelho (pino 7)
    digitalWrite(8, LOW);    // Desliga o LED (pino 8)
  } 
  else if (a > 0) {          // Se 'a' for positivo
    digitalWrite(7, LOW);    //Desliga o LED vermelho
    digitalWrite(8, HIGH);   // Liga outro LED (pino 8)
  }
  else {                     // Se 'a' for zero, desliga ambos os LEDs
    digitalWrite(7, LOW);    
    digitalWrite(8, LOW);
  }
}

// Loop principal: Este bloco é executado repetidamente enquanto o Arduino está ligado
void loop() {
  // Se o usuário digitar "start", começará o processo para calcular a função de 1º grau
  if (Serial.readString() == "start") {

    Serial.setTimeout(5000);   // Define um tempo de espera de 5 segundos para leitura serial

    Serial.print(" escreva o valor de a: ");
    a = Serial.parseFloat();   // Lê o valor de 'a' inserido pelo usuário
    Serial.setTimeout(5000);
    Serial.println(a);   // Exibe o valor de 'a'

    Serial.print(" escreva o valor de b: ");
    b = Serial.parseFloat();   // Lê o valor de 'b'
    Serial.setTimeout(5000);   // Define um tempo de espera de 5 segundos para leitura serial
    Serial.println(b);

    Serial.print(" escreva o intervalo de x, de: ");
    xi = Serial.parseFloat();   // Lê o valor inicial de 'x' (xi)
    Serial.setTimeout(5000);    // Define um tempo de espera de 5 segundos para leitura serial
    Serial.print(xi);

    Serial.print(" para: ");
    xf = Serial.parseFloat();   // Lê o valor final de 'x' (xf)
    Serial.setTimeout(5000);   
    Serial.print(xf);

    Serial.print(" com: iteraçao de: ");
    xa = Serial.parseFloat();   // Lê o valor de incremento de 'x' (xa)
    Serial.setTimeout(5000);
    Serial.println(xa);
    
    verify();   // Chama a função para verificar e controlar os LEDs

    // Laço para calcular e exibir os resultados da função de 1º grau (f(x) = ax + b)
    for (i = xi; i <= xf; i += xa) {
      num = (a * i) + b;   // Calcula o valor da função no ponto 'i'
      Serial.println(num); // Exibe o resultado
      delay(100);          // Espera 100 milissegundos entre as iterações
    }
  }

  // Se o usuário digitar "start2", começa o cálculo para a função de 2º grau
  if (Serial.readString() == "start2") {

    Serial.setTimeout(5000);  // Define um tempo de espera de 5 segundos para leitura serial

    Serial.print(" escreva o valor de a: ");
    a = Serial.parseFloat();   // Lê o valor de 'a'
    Serial.setTimeout(5000);
    Serial.println(a);

    Serial.print(" escreva o valor de b: ");
    b = Serial.parseFloat();   // Lê o valor de 'b'
    Serial.setTimeout(5000);
    Serial.println(b);

    Serial.print(" escreva o valor de c: ");
    c = Serial.parseFloat();   // Lê o valor de 'c'
    Serial.setTimeout(5000);   // Define um tempo de espera de 5 segundos para leitura serial
    Serial.println(c);

    Serial.print(" escreva o intervalo de x, de: ");
    xi = Serial.parseFloat();   // Lê o valor inicial de 'x'
    Serial.setTimeout(5000);
    Serial.print(xi);

    Serial.print(" para: ");
    xf = Serial.parseFloat();   // Lê o valor final de 'x'
    Serial.setTimeout(5000);
    Serial.print(xf);

    Serial.print(" com: iteraçao de: ");
    xa = Serial.parseFloat();   // Lê o valor de incremento de 'x'
    Serial.setTimeout(5000);    // Define um tempo de espera de 5 segundos para leitura serial
    Serial.println(xa);

    verify();   // Chama a função de verificação dos LEDs

    // Laço para calcular e exibir os resultados da função de 2º grau (f(x) = ax² + bx + c)
    for (i = xi; i <= xf; i += xa) {
      num = a*(i * i) + (b *i) + c;   // Calcula o valor da função no ponto 'i'
      Serial.println(num);          // Exibe o resultado
      delay(100);                   // Espera 100 milissegundos entre as iterações
    }
  }
}

Explicação do código completo:

Este código foi projetado para calcular e exibir no monitor serial os resultados de equações de 1º e 2º grau, com base em valores inseridos pelo usuário. Ele faz uso de um Arduino com comunicação serial e LEDs como indicadores. O usuário escolhe entre calcular uma função linear ou quadrática digitando “start” ou “start2”, respectivamente. Para melhor visualização, use o plotter serial, assim será possível observar o gráfico feito pela função.

Funcionamento geral do código:

1. Configuração Inicial (setup): Inicializa a comunicação serial e configura o pino 7 e 8 como saída para controlar os LEDs. Também exibe uma mensagem ao usuário para iniciar a interação.
2. Verificação dos LEDs (verify): Dependendo do valor de ‘a’, aciona ou desliga LEDs nos pinos 7 e 8 para indicar se ‘a’ é positivo, negativo ou zero.
3. Cálculo das Funções (loop): O loop principal aguarda o comando do usuário para iniciar o cálculo da função escolhida:

•   Função de 1º grau: após o comando “start”, solicita os valores de ‘a’ e ‘b’, além do intervalo de ‘x’ e o incremento. Calcula a função linear  f(x) = ax + b para cada valor de ‘x’ no intervalo especificado e exibe os resultados.
•   Função de 2º grau: após o comando “start2”, solicita os valores de ‘a’, ‘b’ e ‘c’, além do intervalo de ‘x’ e o incremento. Calcula a função quadrática  f(x) = ax^2 + bx + c para cada valor de ‘x’ no intervalo e exibe os resultados.

Demonstração

Para a comunicação ocorrer sem defeitos, no monitor serial selecione a opção “No Line Ending”. Lembre-se que a comunicação UART entre arduino e computador é assíncrona, ou seja, é possível ocorrer perda de dados durante a comunicação.

Sobre o autor

Daniel Vasconcelos Tenho 14 anos, meu primeiro contato com eletrônica foi aos 5 anos, e com o Arduino aos 12. Desde então venho explorando mais desse mundo incrível.