Como juntar dois projetos em Arduino Deixe um comentário

Muitas vezes as pessoas vêm até nós com problemas em projetos de médio porte, onde não fazem nem a mais vaga ideia de onde pode estar o problema. Muito menos a sua solução. Nesse post, vamos ver uma forma interessante de se juntar dois projetos em um Arduino e como encontrar e evitar possíveis erros.

Para exemplificar, vamos utilizar uma personagem fictícia (Flop) e uma hipótese de projeto para ela. Vamos supor que a Flop já conhece o básico de Arduino, já fez o curso que vem com o Kit Maker Arduino Iniciante e agora quer fazer seu próprio projeto para resolver um problema em casa.

O projeto

A Flop quer fazer uma mini-cancela automática utilizando o seu Arduino, ela rabiscou num pedaço de papel como deveria ser a sua cancela. Ela viu que precisaria de algo para detectar a presença do carro e algo para movimentar a cancela.

Cancela - Como juntar dois projetos em Arduino

Para a detecção de presença, ela decidiu utilizar um Sensor de Distância Ultrassônico HC-SR04. Para a movimentação, ela sabia que um pequeno servo seria suficiente. Ela escolheu o Micro Servo 9g SG90 TowerPro, que já vinha no kit que ela tinha comprado. Uma vez especificados os componentes, ela já tinha a lista do que precisaria:

Para fazer esse projeto, ela viu o post no guia do Kit Maker Arduino como funciona o servo motor, colocou o sensor ultrassônico junto conforme o post ensina e… Nada funcionou. E agora?

Dividir para conquistar

Como dizia o imperador Júlio César “divide et impera“. Quando se deseja juntar dois componentes em um único projeto é interessante separar bem cada um deles e entendê-los separadamente. O ideal é montar um projeto separado para cada um dos componentes e juntar os dois projetos em um Arduino.

É uma boa prática dominar tanto a montagem eletrônica quanto a parte de programação. Uma vez dominado como funciona a ligação do componente com o Arduino – se usa uma saída analógica, digital, PWM ou algum tipo de comunicação – e fica a programação – como inicializa o componente, o que muda ao alterar a montagem, quais parâmetros são utilizados para controlá-lo e o que esses parâmetros representam – é aconselhável você juntar os componentes.

No caso da Flop, fica fácil dividir o problema, é um sensor (o HC-SR04) e um atuador (o micro servo). Algumas vezes é mais complexo e a divisão nem sempre é tão visível, mas sempre tente dividi-lo em problemas menores. Resolva-os separadamente, domine cada um dos elementos, para depois juntar em uma solução única.

Dominar cada um dos elementos

Uma vez divididos, para juntar dois projetos em Arduino, é interessante estudá-los separadamente. Como vimos anteriormente, a Flop viu que tinham posts ensinando como funcionam os dois componentes, a nossa sugestão é dominar cada um deles separadamente, ver como os componentes são ligados e como funciona sua programação no Arduino.

Entendo o servo motor

Como vimos na aula sobre o servo motor, o servo motor é conectado ao Arduino por três fios, o vermelho para o 5 V, o marrom para o GND, e o laranja em alguma porta analógica (que tem o til ‘~’ do lado do número). É importante saber o que o componente precisa para ser acionado.

Projeto servo motor com botão - Como juntar dois projetos em Arduino

Na parte de programação, é interessante ver as bibliotecas utilizadas e como o motor é acionado. Abaixo temos a programação da aula.

//   Projeto 8 - Acionando um Motor

#include <Servo.h>

Servo meuServo;
int botao = 7;

void setup() 
{
  pinMode(botao, INPUT_PULLUP); // define o botão como saidas 
}

void loop() 
{
  meuServo.attach(9);
  if(digitalRead(botao) == LOW)
  {
    for(int angulo=0; angulo<=180; angulo++) // Aumenta o angulo ate chegar em 180 graus
    {
      meuServo.write(angulo);
      delay(10);
    }
    for(int angulo=180; angulo>=0; angulo--)// Diminui o angulo do servo
    {
      meuServo.write(angulo);
      delay(10);
    }
  }
  meuServo.detach();
}

Veja que é necessária a inclusão da biblioteca Servo.h no começo código, pois ela já vem instalada com a IDE. Também é necessário declarar o servomotor, como feito nesta linha “Servo meuServo;”

Dentro do loop, é necessário “ligar” o servo com o comando “meuServo.attach(9);”  e “desligar” o servo com “meuServo.detach();”. Também é possível perceber dentro do código como é feito o comando para o posicionamento do servo, na linha “meuServo.write(angulo);”.

Entendido o código, podemos diminuí-lo para o mínimo necessário para fazê-lo funcionar. Retiramos o botão do circuito e as estruturas iffor. Tente você fazer isso, ainda que mentalmente, o código deve ficar próximo a este programa que apenas coloca em uma posição o servo, espera um tempo e coloca em outra.

//Programa: Servo motor minimo
//Autor: FilipeFlop

#include <Servo.h> // Inclui a biblioteca
Servo meuServo; // Declara o servo motor 

void setup() {
  // Nao precisamos de nada aqui
}

void loop() {
  meuServo.attach(9); // Liga o servo motor
  
  meuServo.write(0); // Posiciona o motor em 0
  delay(1000); // Aguarda 1 segundo
  
  meuServo.write(45); // Posiciona o motor em 45
  delay(1000); // Aguarda o 1 segundo

  meuServo.detach(); // Desliga o servo motor
}

Veja que os comentários no código ajudam o entendimento do programa. É sempre bom comentar seu código até para você mesmo poder entendê-lo no futuro.

Visto como são feitas as conexões e a programação desse projeto, podemos dizer que dominamos o funcionamento do servo motor e podemos passar pra próxima etapa.

Entendendo o sensor ultrassônico

A Flop até viu o funcionamento do Sensor ultrassônico HC-SR04 no post do blog, mas não fez uma análise do seu funcionamento na hora de juntar os dois projetos em um Arduino só.

Conforme visto no post, a ligação do sensor é feita da seguinte forma:

Projeto HC-SR04 - Como juntar dois projetos em Arduino

Podemos ver que são utilizados os pinos de alimentação do Arduino (5 V e GND) e duas portas digitais.

//Programa: Conectando Sensor Ultrassonico HC-SR04 ao Arduino
//Autor: FilipeFlop

//Carrega a biblioteca do sensor ultrassonico
#include <Ultrasonic.h>

//Define os pinos para o trigger e echo
#define pino_trigger 4
#define pino_echo 5

//Inicializa o sensor nos pinos definidos acima
Ultrasonic ultrasonic(pino_trigger, pino_echo);

void setup()
{
  Serial.begin(9600);
  Serial.println("Lendo dados do sensor...");
}

void loop()
{
  //Le as informacoes do sensor, em cm e pol
  float cmMsec, inMsec;
  long microsec = ultrasonic.timing();
  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
  inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);
  //Exibe informacoes no serial monitor
  Serial.print("Distancia em cm: ");
  Serial.print(cmMsec);
  Serial.print(" - Distancia em polegadas: ");
  Serial.println(inMsec);
  delay(1000);
}

No código podemos perceber, assim como feito com o servo, o uso de uma biblioteca, na linha “#include <Ultrasonic.h>”. Neste caso, porém é necessário fazer a instalação dela, conforme ensina o post ou baixando o arquivo no formato .ZIP e adicionar na IDE do Arduino. Para isso, vá em “Sketch -> Incluir Bibliotecas -> Adicionar Biblioteca .ZIP” e selecione o arquivo.

Incluir biblioteca na IDE do Arduino

Após a inclusão da biblioteca, é inicializado o sensor, com o comando “Ultrasonic ultrasonic(pino_trigger, pino_echo);”. Também é inicializada a porta serial, que não é obrigatória mas é uma ótima forma de entender o sensor e encontrar problemas na lógica do código.

Uma vez inicializado o sensor, para ler os dados é necessário utilizar uma variável, no programa é chamada de “microsec” e recebe o valor da função “ultrasonic.timing()“. A leitura dos dados é feita na linha “cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);” onde a variável “cmMsec” recebe o valor lido e depois é enviada para a serial. Sem enviar o valor para a serial, teria que ser colocada outra forma de se saber o valor lido.

Como nesse código tem poucos comandos além do necessário, não é válido mostrar uma forma reduzida aqui. Seria possível apenas retirar a leitura do valor em polegadas.

Finalmente juntar dois projetos em Arduino

Entendido o funcionamento dos dois componentes, é chegada a hora de juntar os dois em um projeto pro Arduino. Mais uma vez, dividir pra conquistar. Vamos ver como é feita a montagem do circuito com os dois componentes e, depois, como juntar os dois programas.

Juntando os circuitos

Quando estudamos os componentes separadamente, vimos os pinos que cada componente precisa:

Servo motor

  • 5 V
  • GND
  • Sinal (saída analógica)

Sensor  ultrassônico 

  • 5 V
  • Echo (porta digital)
  • Trig (porta digital)
  • GND

No circuito com os dois componentes juntos, podemos utilizar o mesmo pino de 5 V e de GND para ambos os componentes. Além desses dois pinos do Arduino, precisamos de outros dois para o sensor ultrassônico, que podemos manter os mesmos vistos no post (4 e 5). Para o servo motor, qualquer saída analógica poderia funcionar, neste caso mantivemos a da aula (9).

Circuito final - Como juntar dois projetos em Arduino

Juntando os programas

Análogo ao que foi feito com os circuitos, para juntar os dois programas em um único Arduino você deve atentar-se ao que precisa realmente ser colocado e o que não pode ser repetido, não podemos simplesmente copiar e colar os dois programas juntos e esperar que funcione.

Um programa em Arduino possui duas estruturas principais “setup()” e “loop()“, como visto na Aula 1 do guia.

setup() – Parte do programa que você configura as opções iniciais do seu programa: os valores iniciais de uma variável, se uma porta será utilizada como entrada ou saída, mensagens para o usuário, etc. Essa função irá executar apenas uma vez quando o Arduino for ligado.

loop() – Diferente da função setup(), essa parte do programa repete uma estrutura de comandos de forma contínua ou até que algum comando de “parar” seja enviado ao Arduino. Vamos ver exatamente como isso funciona ao decorrer dos projetos.

Acontece que em um programa Arduino só pode ter uma de cada, então se deve o que é necessário em cada um dos códigos e colocar dentro do “setup()” e do “loop()” de acordo com o que vimos quando estudamos os códigos.

Resumidamente, o programa posiciona o servo motor em uma determinada posição (45º) e envia “Abriu” para o computador quando existe algo próximo do sensor ultrassônico (menor que 5 cm). Se não existe nada próximo, coloca o servo em outra posição (0º) e envia “Fechou”.

//Programa: Cancela automática
//Autor: FilipeFlop
 
//Carrega as bibliotecas do sensor ultrassonico e do servo
#include <Ultrasonic.h>
#include <Servo.h>

// Para o sensor ultrassonico
//Define os pinos para o trigger e echo
#define pino_trigger 4
#define pino_echo 5 
//Inicializa o sensor nos pinos definidos acima
Ultrasonic ultrasonic(pino_trigger, pino_echo);

// Para o servo motor
Servo meuServo; // Declara o servo motor


void setup()
{
  // Colocamos a serial para verificar possiveis erros
  Serial.begin(9600);
  Serial.println("Lendo dados do sensor...");
}
 
void loop()
{
  //Le as informacoes do sensor ultrassonico em cm
  float cmMsec;
  long microsec = ultrasonic.timing();
  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
  
  meuServo.attach(9); // Liga o servo motor

  // Você pode alterar esse valor de acordo com o funcionamento desejado
  if(cmMsec < 5) // Verifica se o valor do sensor é menor que 5
  {
    // Se o valor for
    meuServo.write(45); // Posiciona o motor em 45
    delay(1000); // Aguarda 1 segundo
    Serial.println("Abriu"); // Envia mensagem pela serial
  }
  else
  {
    // Senão
    meuServo.write(0); // Posiciona o motor em 0
    delay(100); // Aguarda 0,1 segundo
    Serial.println("Fechou"); // Envia mensagem pela serial

  }
  
  meuServo.detach();// Desliga o servo motor
  
  // Colocamos a distancia na serial para ajustarmos o sensor
  Serial.print("Distancia em cm: ");
  Serial.println(cmMsec);
}

Perceba que no início do programa (linhas 5 e 6) declaramos as duas bibliotecas necessárias. Dentro do “setup()” não precisaria ser colocado nada,  mas inicializamos a porta serial para nos auxiliar a encontrar erros no programa.

No “loop()” definimos o comportamento do projeto. No começo do loop lemos a medição do sensor ultrassônico (linha 31), comparamos a medição com o valor 5 (linha 36). Esse valor pode ser alterado de acordo com o seu sensor e como você deseja o comportamento. Fica muito mais fácil ajustar esse valor quando você acompanha a medição do sensor através da serial. Se a medida for menor que o valor, colocamos o servo em uma posição (linha 39); se for maior, colocamos em outra posição (linha 46).

Conclusão

Agora que a Flop já conseguiu juntar o servo motor e o sensor ultrassônico em um único Arduino, ela pode se preocupar com as outras coisas do seu projeto. Vale lembrar que antes de juntar dois projetos em um Arduino ela queria fazer uma cancela para carros.

Se você quisesse juntar mais projetos nesse projeto, como um leitor RFID, por exemplo, o procedimento seria parecido. Estude o componente separado, replicando um post, depois veja como encaixaria nesse projeto.

E aí, curtiu aprender como juntar projetos em um Arduino? Ajude-nos a melhorar o blog comentando abaixo sobre este tutorial. Não se esqueça de visitar o fórum da FilipeFlop!

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

{"cart_token":"","hash":"","cart_data":""}