quarta-feira, 17 de março de 2021

Controlando Servo Motor a distância usando Joystick via RF 433 Mhz via arduino (sem fio)

Fala makers, primeiro de tudo gostaria de pedir pra vocês se escreverem la no canal do Youtube e fortalecer o trabalho, estarei postando agora com muito mais frequência.  Clique aqui pra se escrever no canal e já deixe sua solicitação de tutoriais. 



Chegou o tão esperado tutorial, nesse tutorial iremos controlar um servo motor a distância utilizando o módulo RF 433 Mhz. Já temos um tutorial de com utilizar esse módulo, você pode acessar clicando aqui, você também pode acessar o vídeo tutorial clicando aqui.

Há algum tempo atrás era muito complicado controlar um servo motor utilizando as biblioteca VirtualWire.h junto com o a biblioteca Servo.h, Ambas as bibliotecas utilizam o Timer1, por conta desse problema foi criada a biblioteca ServoTimer2.h. Agora chega de enrolação, vamos a introdução.

Vamos entender como como funciona os módulos RF 433 Mhz

Figura 1- Módulos RF 433Mhz


No circuito os dois módulos foram usados antenas, para grandes distâncias (até 200 metros em local aberto), a instalação da antena é essencial. Outro detalhe é que o módulo transmissor aceita tensões na faixa de 3,5 a 12v, o que também faz uma grande diferença no alcance da transmissão. São componentes básicos para comunicação via rádio frequência, presente em sistemas de alarmes, controle remoto, aquisição de dados e robótica em geral. Seu funcionamento é bem simples o transmissor envia uma série de dados para o receptor fazendo um método de transmissão simplex. Porém é necessário que você utilize um encoder (codificador) e um decoder (decodificador) para facilitar o processo de transmissão entre seus módulos, Nesse caso vamos utilizar 2 arduinos para essa comunicação.


Biblioteca VirtualWire.h

Nessa tutorial estamos utilizando a biblioteca VirtualWire.h, ela facilita a aplicação desses módulos, sendo uma biblioteca bastante útil e simples. Com as bibliotecas do arduino fica muito fácil você construir seu próprio dispositivos, pois não necessita de especialização ou conhecimento prévio. Você pode baixar essa biblioteca clicando aqui.


Servo Motor

O servo motor é um atuador rotativo ou linear que permita o controle de posição angular ou linear, velocidade e aceleração. Consiste em um motor adequado acoplado a um sensor de realimentação. Eles são usados em aplicações com robótica, máquinas, CNC ou manufatura automatizada. Basicamente você consegue controla a posição com precisão controlando o ângulo. Nesse projeto iremos de forma aleatória definir posições passando o conhecimento necessário para que vocês possam utilizar em seus projetos e modificar. 


   Biblioteca ServoTimer2.h

Amabas as bibliotecas Servo.h e a VirtualWire.h  utilizam o mesmo Timer, ou seja, você não pode utilizar as duas no mesmo projeto. Para contorna essa situação foi desenvolvida a ServoTimer2.h, tendo duas diferenças, primeiro ela utiliza o Timer2, segundo é a forma com que a posição é controlada, enquanto que na biblioteca Servo.h a posição é controlado pela posição em graus a ServoTimer2.h é controlada por pulso. O Pulso máximo é 2250 que é para 180 graus e 750 que é 0 grau, você pode baixar clicando aqui.


 Joystick

O Joystick é similar a dois potenciômetros conectados, um para o controle vertical(eixo Y) e outro para o controle horizontal(eixo X). Os potenciômetros variam a resistência, agindo como sensor, portanto variando a a tensão de acordo com a rotação.

creat.arduino
Funcionamento interno do joystick


 Montagem do Transmissor

A montagem do transmissor é simples, estamos utilizando o módulo Joystick Ky-023, e o transmissor RF 433 Mhz, estamos utilizando 2 portas analógicas e duas portas digitais.




Montagem do Receptor

Na montagem do receptor fique atento a pinagem do seu servo motor, colocamos um led para testar a comunicação, referente ao receptor a montagem é simples. Estamos utilizando 3 portas digitais.



Sketch Transmissor

/* MSmaker RF Example
  developed by MSmaker
  date: March 17, 2021
  universomakers@gmail.com
*/
#include <VirtualWire.h> //Inclui a biblioteca VirtualWire.h


int eixo_X = A0; //Define o pino analógico A0 como eixo_X
int eixo_Y = A1; //Define o pino analógico A1 como eixo_X
int botao = 2; //Define o pino digital 2 como botão, botão do Joystick
char *dado ; //Cria a variável que ira armazenar a informação pré definida enviadas pelos botões

void setup()
{

  pinMode (botao, INPUT_PULLUP); //Define o botao como entrada digital e ativa o PULLUP ( resistor interno)

  //Configura o Arduino para trabalhar como transmissor
  vw_set_ptt_inverted(true);
  vw_setup(2000);
  vw_set_tx_pin(3);//Configura o pino 3 como tx
  //===================================================
  Serial.begin(9600);
  //Configura o estado das portas digitais
  pinMode(3, OUTPUT);//Configura pino 3 como saída
  pinMode(4, INPUT);//Configura o pino 4 como entrada
}

void loop() {

  if ((analogRead(eixo_X)) == 0) { //Verifica se o valor é 0
    Serial.println("PARA BAIXO"); //Imprime no monitor serial apenas para verificação
    dado = "A"; //Armazena o dado pré determinado
    vw_send((uint8_t *)dado, strlen(dado)); //Envia a variável "dado"
    vw_wait_tx(); //Aguarda o fim de transmissão
    delay(100); //Aguarda um tempo para a próxima leitura
    Serial.println(dado);//Imprime no monitor serial verificação
  } else {
    if ((analogRead(eixo_X)) == 1023) { //Verifica se o valor é 1023
      Serial.println("PARA CIMA"); //Imprime no monitor serial serial verificação
      dado = "B"; //Armazena o dado pré determinado
      vw_send((uint8_t *)dado, strlen(dado)); //Envia a variável "dado"
      vw_wait_tx(); //Aguarda o fim de transmissão
      delay(100); //Aguarda um tempo para a próxima leitura
      Serial.println(dado);//Imprime no monitor serial verificação
    } else {
      if ((analogRead(eixo_Y)) == 0) { //Verifica se o valor é 0
        Serial.println("ESQUERDA"); //Imprime no monitor serial verificação
        dado = "C"; //Armazena o dado pré determinado
        vw_send((uint8_t *)dado, strlen(dado)); //Envia a variável "dado"
        vw_wait_tx(); //Aguarda o fim de transmissão
        delay(100); //Aguarda um tempo para a próxima leitura
        Serial.println(dado);//Imprime no monitor serial verificação
      } else {
        if ((analogRead(eixo_Y)) == 1023) { //Verifica se o valor é 1023
          Serial.println("DIREITA"); //Imprime no monitor serial verificação
          dado = "D"; //Armazena o dado pré determinado
          vw_send((uint8_t *)dado, strlen(dado)); //Envia a variável "dado"
          vw_wait_tx(); //Aguarda o fim de transmissão
          delay(100); //Aguarda um tempo para a próxima leitura
          Serial.println(dado);//Imprime no monitor serial verificação
        } else {
          if (digitalRead(botao) == LOW) { //Verifica se o botão esta pressionado
            Serial.println("BOTAO PRESSIONADO"); //Imprime no monitor serial
            dado = "E"; //Armazena o dado pré determinado
            vw_send((uint8_t *)dado, strlen(dado)); //Envia a variável "dado"
            vw_wait_tx(); //Aguarda o fim de transmissão
            delay(100); //Aguarda um tempo para a próxima leitura
            Serial.println(dado);//Imprime no monitor serial verificação
          }
        }
      }
    }
  }
  delay(500); //Intervalo de 500 milissegundos
}

Sketch Receptor

/* MSmaker RF Example
  developed by MSmaker
  date: March 17, 2021
  universomakers@gmail.com
*/
#include <VirtualWire.h> //Inclui a biblioteca VirtualWire.h
#include"ServoTimer2.h"// Inclui a biblioteca ServoTimer2.h
ServoTimer2 servo1;//Configura um servo motor

void setup()
{
  servo1.attach(6);
  //Configura o Arduino para trabalhar como receptor
  vw_set_ptt_inverted(true);
  vw_setup(2000);
  vw_set_rx_pin(3);//Configura o pino 3 como RX
  vw_rx_start();
  //=================================================

  pinMode(3, INPUT);//Configura o pino 3 RX como entrada
  pinMode(4, OUTPUT);//configura o pino 4 como saída, nesse caso vamos colocar um led pra teste
  Serial.begin(9600);//Configura a velocidade da porta serial
}


void loop()
{
  char cod;//Cria uma variavel para armazenar o dado recebido.
  uint8_t buf[VW_MAX_MESSAGE_LEN]; //Recebe os dados e armazena na variável buf
  uint8_t buflen = VW_MAX_MESSAGE_LEN; //Armazena na variável buflen o tamanho do dado recebido

  if (vw_get_message(buf, &buflen)) //Pega a mensagem que foi recebida
  {

    cod = buf[0]; //Converte a variável em Char
    Serial.println(cod); //Para verificar valores recebidos e corrigir possiveis erros
    if (cod == 'A') // Compara a informação recebida e se for a correspondente aciona o servo motor
    {
      Serial.println(cod); //Imprime o dado de entrada para verificação apenas
      servo1.write(750);  //Pulso minimo 0 graus
    }
    if (cod == 'B')//Compara a informação recebida e se for a correspondente aciona o servo motor
    {
      Serial.println(cod);//Imprime o dado de entrada para verificação apenas
      servo1.write(1500);  //Pulso para 90 graus
    }
    if (cod == 'C')//Compara a informação recebida e se for a correspondente aciona o servo motor
    {
      Serial.println(cod);//Imprime o dado de entrada para verificação apenas
      servo1.write(1950);  //Pulso para 120 graus
    }
    if (cod == 'D')//Compara a informação recebida e se for a correspondente aciona o servo motor
    {
      Serial.println(cod);//Imprime o dado de entrada para verificação apenas
      servo1.write(2250);  //Pulso maximo para 180 graus
    }
    if (cod == 'E')//Compara a informação recebida e se for a correspondente aciona o LED
    {
      Serial.println(cod); //Imprime o dado de entrada para verificação apenas
      digitalWrite(4, !digitalRead(4)); // Inverte o estado da saída D4
    }
  }

}

segunda-feira, 15 de março de 2021

Utilizando Sensor de temperatura LM35 com o Arduino muito fácil

Montagem Arduino UNO e LM35

 


No quesito sensor de temperatura o componente mais utilizado é o LM35, muito fácil de configurar e utilizar. Não é necessário calibração tendo uma resolução de 0,5º C com uma faixa de medição de  -55º C a + 150º C.

Pinagem LM#%



É fornecida um a tensão de saída de 10mV/ ° C, como essa tensão de saída é variável é necessário utilizar a entrada analógica do arduino, que ira fazer a conversão do valor analógico para digital, acesse esse tutorial para conhecer um pouco mais sobre tensão analógica Controle um Cooler a distância com um potenciômetro.  


Arduino Nano


1 Aplicações

O LM35 é muito versátil, tudo que se pode imaginar referente a medir a temperatura você pode criar, vou citar alguns exemplos, mas como foi dito, use a sua imaginação para criar os seus projetos.

1 Verificar temperatura ambiente

O mais básico você pode utilizar um arduino mais o LM35, nesse caso você ira verificar a temperatura com o Monitor Serial, seria basicamente o que estamos fazendo nesse tutorial.

2  Sensor de temperatura por disparo 

Nesse caso você vai criar um sensor de temperatura que ira acionar um dispositivo de segurança ao atingir certa temperatura, ele ira acionar um cooler ou até mesmo desligar o gerador de calor, sendo muito utilizado em fonte e em maquinas. Você pode ter uma ideia do acionamento de um cooler aqui

3 Manter a temperatura de uma estufa ou ambiente

Você precisa de uma temperatura especifica, seja para o cultivo de plantas, manter algum bicho de estimação aquecido sem o prejudicar, e por ai vai. Nesse caso você controla a temperatura do ambiente através do LM35, onde você vai ligando e desligando o gerador de calor.

Esses três são os mais utilizados, a partir dai você já pode utilizar esses exemplos para criar o seu próprio projeto. 

A Sketch esta comentada para você entender o que cada linha significa, sendo assim você pode alterar da forma que melhor te atender. 


Acesse o vídeo desse tutorial com a sketch comentada.


Sketch

#define lm35 A0 //Entrada analógica conectado no output que será utilizada

 
void setup() {
Serial.begin(9600); // Define a velocidade da porta serial
pinMode(lm35, INPUT); //Define o pino de entrada do sensor como entrada analógica 
}
 
void loop() {
float valor_analog_lm35 = float(analogRead(lm35)); // Realiza a leitura do sensr
float tensao = (valor_analog_lm35 * 5) / 1023; // Convertemos o valor para tensão 
float temperatura = tensao / 0.010; // Dividimos a tensão por 0.010 (10mV)
 
Serial.print("A temperatura eh ");
Serial.println(temperatura); // Printa na tela as informações 
 
delay(1000); // aguarda 1 segundo
}

domingo, 14 de março de 2021

Arduino Nano não carrega o programa - resolva da maneira mais simples


Fala Makers, há algum tempo atrás comprei alguns arduinos nano pra fazer alguns testes ainda mais pelo tamanho e a disposição em certos lugares. Porém de deparei com um problema, o PC reconhece o arduino e a porta mas não carregava o programa, depois de um tempo dava erro.

Como eu estava há algum tempo sem utilizar apanhei um pouco, a solução é bem simples para as pessoas que já conhecem o arduino e programam com frequência. Realmente é em simples, como consege resolver esse problem apenas seguindo a lógica ou por tentativa e erro. Segue abaixo as imagens do passo a passo.


1- Defina o tipo de Arduino 


Você deve selecionar o modelo da placa Arduino que de acordo com a placa que você esta utilizando, no nosso caso escolhemos o arduino nano, se você colocar outra placa não irá funcionar.


2  Escolha o processador utilizado 



Estamos utilizando um arduino certo? 

Então o que vem na cabeça, ATmega328P certo?

Sim você não esta errado, porém com eu falei anteriormente, é tentativa e erro. Só tinha duas opções, o arduino esta com defeito ou o problema ser no software, ah você incluir mais um o firmware.
Nesse caso resolveu alterando a IDE(programa do arduino), deixamos padrão e não funcionou, fiz uma breve pesquisa e provavelmente o arduino que estou utilizando esta com o firmware desatualizado, porém é um pouco complicado, mas vou trazer essa opção em breve.  
Mudei para a opção ATmega328P old Bootloader(antigo), e funcionou. 
Você deve testar, se você tem dúvidas referente a alguma coisa que esta projetando você deve testar, só assim vai aprender e evoluir por conta e mais rápido.

3 Defina a porta COM



Essa ultima opção é feita para qualquer arduino, é essencial escolher a porta correta, se você tiver mais de um arduino você deve testar, desconecta um e verifica, o que continuar será o arduino que ficou conectado.




Então foi isso makers, sem enrolação, em breve mais tutoriais.  






Desenvolvimento de projetos sugerido por seguidores

 Estamos de volta com novidades, algum de nossos projetos serão atualizados e incluído sugestões feitas na própria página do tutorial, se vocês tem alguma sugestões de projetos, ou viram alguma coisa diferente em algum lugar e acha difícil de ser verdade ou de ser feito mande para nós pelo comentário lá no Youtube clicando aqui.

Serão escolhidos sugestões de projetos de seguidores, os arquivos estarão disponíveis para download aqui na página.



Você também também pode deixar um comentário aqui na página, mas não se esqueça de se inscrever no canal do youtube.
Em breve teremos sorteio de kits para você criar seu próprio projeto.



segunda-feira, 8 de março de 2021

Faça o seu próprio Sensor de Estacionamento com Arduino

 



Fala Makers, estamos de volta e agora com um projeto acabado de sair do forno. Já pensou em fazer o seu próprio sensor de estacionamento? 

Vamos utilizar o famoso sensor ultrassônico HC-SR04 que é capaz de medir distâncias de 2cm a 4m com ótima precisão e baixo preço. Este módulo possui um circuito pronto com emissor e receptor acoplados e 4 pinos (VCC, Trigger, ECHO, GND) para medição.

Ele detecta a distância do objeto mais próximo à frente do sensor, enviando um pulso de ultrassom que ao encontrar um objeto irá retornar na entrada . A placa Arduino envia um pulso curto para acionar a detecção , em seguida, escuta um pulso no mesmo pino usando a função pulseIn (). A duração desse segundo pulso é igual ao tempo que o ultrassom leva para se deslocar até o objeto e voltar para o sensor usando a velocidade do som, este tempo pode ser convertido para distância correspondente.


Montagem do circuito



Material utilizado: 

Arduino
Sensor ultrassônico hc sr04
Buzzer 5V
Jumpers

Sketch

Download da biblioteca Ultrasonic

//universomakers@gmail.com
//https://www.youtube.com/channel/UCJQsBkCMuN6S7ZygGTPZ7Iw
//https://www.facebook.com/universomakers

//MSMakers

#include <Ultrasonic.h> //biblioteca

#define pino_trigger 4 //configuração dos pinos
#define pino_echo 5

Ultrasonic ultrasonic(pino_trigger, pino_echo); // Inicia a biblioteca

const int buzzer =  13; // configura o pino 13 para o buzzer 
int intervalo = 1000; // A frequencia que o buzzer oscila
int cont = 0; // Conta o tempo que o sensor ficou parado, distancia minima 

int BuzzState = LOW; //Variavel com o estado do buzzer, começando desligado
unsigned long previousMillis = 0;//configura o millis iniciando em 0

void setup() {

  Serial.begin(9600);// Configura a velocidade da porta serial
  pinMode(buzzer, OUTPUT);//configura o buzzer como saída
}

void loop() {

  unsigned long currentMillis = millis();

  float cmMsec; // variavel para armazena o valor em cm
  long microsec = ultrasonic.timing();// configuração exigida pela biblioteca
  cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);//converte o valor para cm


//Apenas ira printar na tela se for maior de 0.8 e menor de 30cm
  if (cmMsec < 30.0 && cmMsec > 0.8 ) {
    Serial.print("Distancia em cm: ");
    Serial.print(cmMsec);
    Serial.println(" ");

  } 
  
//Ira variar a frequancia do buzzer, 
  if (cmMsec > 20.0 && cmMsec < 30.0) {
    intervalo = 100;

  }
  else if (cmMsec > 10.0 && cmMsec < 20.0) {
    intervalo = 50;

  } else if ( cmMsec < 10.0 && cmMsec > 5.0) {
    intervalo = 10;

  } else if ( cmMsec < 5.0 && cmMsec > 0.8) {
    intervalo = 5;

  }
  //aumento o intervalo e corta o sinal do buzzer, chegou na distancia minima
  else {
    intervalo = 1000;
    digitalWrite(buzzer, LOW);

  }

//Faz a verificação sendo acionado a quantidade de vezes o intervalo
  if (currentMillis - previousMillis >= intervalo && intervalo < 500 && cont <= 200) {
    Serial.println(cont);//printa informação na tela, apenas para verificação

    cont ++;//conta o tempo acionando na mesma frequencia
    previousMillis = currentMillis;//salva o valor atual do millis

    //inverte o estado do buzzer

    if (BuzzState == LOW) {
      BuzzState = HIGH;

    } else {
      BuzzState = LOW;
    }

    digitalWrite(buzzer, BuzzState); //aciona ou desaciona o buzzer dependendo do estado
  }else if(cmMsec >28){
    cont = 0; // Se a disctancia for maior que 28cm o buzzer sera desligado
    
  }

}