Carro 4wd Arduino

Nesta postagem vamos montar e programar um carro 4WD que desvia de obstáculos;

Imagem meramente ilustrativa

Para o projeto iremos utilizar:

-  Kit Chassi 4wd;

-  Arduino uno;

-  Micro servo 9G SG90;

-  Sensor ultrassônico HC-SR04; 

-  Driver motor Ponte H L298n;

-  Suporte para 4 pilhas AA;

-  Suporte Pan Tilt;

- Jumpers macho/macho;

- Jumpers macho/fêmea;

- Jumpers fêmea/fêmea;

Faça a montagem do chassi 4WD, para detalhes acesse AQUI;

Faça as ligações conforme desenho abaixo:

Obs: Se na hora de testar o carrinho as rodas tiverem rotação invertida, inverta as ligações aos pinos digitais.

Em alguns códigos de programação deve ser alterada a entrada A0 e  A1 por A1 e A2 no Arduino, verifique o desenho e o código.

Copie e cole o código no arduino no IDE e carregue o programa no arduino ou acesse o link com o código AQUI, 

Obs: Adicione as bibliotecas Servo.h e NewPing.h ao arduino IDE, caso não tenha;

#include <Servo.h>          //Servo motor library. This is standard library
#include <NewPing.h>        //Ultrasonic sensor function library. You must install this library

//our L298N control pins
const int LeftMotorForward = 7;
const int LeftMotorBackward = 6;
const int RightMotorForward = 4;
const int RightMotorBackward = 5;

//sensor pins
#define trig_pin A1 //analog input 1
#define echo_pin A2 //analog input 2

#define maximum_distance 250
boolean goesForward = false;
int distance = 150;

NewPing sonar(trig_pin, echo_pin, maximum_distance); //sensor function
Servo servo_motor; //our servo name


void setup(){

  Serial.begin(9600);

  pinMode(RightMotorForward, OUTPUT);
  pinMode(LeftMotorForward, OUTPUT);
  pinMode(LeftMotorBackward, OUTPUT);
  pinMode(RightMotorBackward, OUTPUT);
  
  servo_motor.attach(10); //our servo pin

  servo_motor.write(115);
  delay(2000);
  distance = readPing();
  delay(100);
  distance = readPing();
  delay(100);
  distance = readPing();
  delay(100);
  distance = readPing();
  delay(100);
}

void loop(){

  int distanceRight = 0;
  int distanceLeft = 0;
  delay(50);

  if (distance <= 20){
    moveStop();
    delay(300);
    moveBackward();
    delay(400);
    moveStop();
    delay(300);
    distanceRight = lookRight();
    delay(300);
    distanceLeft = lookLeft();
    delay(300);

    if (distance >= distanceLeft){
      turnRight();
      moveStop();
    }
    else{
      turnLeft();
      moveStop();
    }
  }
  else{
    moveForward(); 
  }
    distance = readPing();
}

int lookRight(){  
  servo_motor.write(50);
  delay(500);
  int distance = readPing();
  delay(100);
  servo_motor.write(115);
  return distance;
}

int lookLeft(){
  servo_motor.write(170);
  delay(500);
  int distance = readPing();
  delay(100);
  servo_motor.write(115);
  return distance;
  delay(100);
}

int readPing(){
  delay(70);
  int cm = sonar.ping_cm();
  if (cm==0){
    cm=250;
  }
  return cm;
}

void moveStop(){
  
  digitalWrite(RightMotorForward, LOW);
  digitalWrite(LeftMotorForward, LOW);
  digitalWrite(RightMotorBackward, LOW);
  digitalWrite(LeftMotorBackward, LOW);
}

void moveForward(){

  if(!goesForward){

    Serial.println("==moveForward==");

    goesForward=true;
    
    digitalWrite(LeftMotorForward, HIGH);
    digitalWrite(RightMotorForward, HIGH);
  
    digitalWrite(LeftMotorBackward, LOW);
    digitalWrite(RightMotorBackward, LOW); 
  }
}

void moveBackward(){

  goesForward=false;

  Serial.println("==moveBackward==");

  digitalWrite(LeftMotorBackward, HIGH);
  digitalWrite(RightMotorBackward, HIGH);
  
  digitalWrite(LeftMotorForward, LOW);
  digitalWrite(RightMotorForward, LOW);
  
}

void turnRight(){

  Serial.println("==turnRight==");

  digitalWrite(LeftMotorForward, HIGH);
  digitalWrite(RightMotorBackward, HIGH);
  
  digitalWrite(LeftMotorBackward, LOW);
  digitalWrite(RightMotorForward, LOW);
  
  delay(500);
  
  digitalWrite(LeftMotorForward, HIGH);
  digitalWrite(RightMotorForward, HIGH);
  
  digitalWrite(LeftMotorBackward, LOW);
  digitalWrite(RightMotorBackward, LOW);
 
  
  
}

void turnLeft(){

  Serial.println("==turnLeft==");

  digitalWrite(LeftMotorBackward, HIGH);
  digitalWrite(RightMotorForward, HIGH);
  
  digitalWrite(LeftMotorForward, LOW);
  digitalWrite(RightMotorBackward, LOW);

  delay(500);
  
  digitalWrite(LeftMotorForward, HIGH);
  digitalWrite(RightMotorForward, HIGH);
  
  digitalWrite(LeftMotorBackward, LOW);
  digitalWrite(RightMotorBackward, LOW);
}

Acione o carrinho e boa diversão.

Para comprar o Kit, acesse o link AQUI;

Braço robótico Arduino Completo

 

Montagem e programação, veja abaixo:

Descrição

Kit Braço Robótico Acrílico + Servos + Parafusos + Arduino + joystick


Itens Inclusos:
1 Kit braço robótico em acrílico
4 Servos 9g
1 Arduino uno R3
1 Joystick duplo
1 Kit de parafusos para montagem
1 Cabo USB

Observações:
* O braço segue desmontado.

*** Dimensões: aproximadamente 15cm de altura e o braço estendido aproximadamente 20cm.

Necessário ter conhecimentos em eletrônica e programação para o funcionamento do kit robótico.

COMPRAR:

_________________________________________________________________________________

Braço robótico Arduino com Joystick duplo

Neste projeto vamos aprender a montar e programar um braço robótico controlado pelo Arduino Uno e um shield joystick duplo. 

Para iniciar vamos carregar o código no Arduino Uno e montar o braço, o manual de montagem está disponível AQUI e o código está abaixo ou AQUI.

Conecte o shield ao Arduino:

Carregue o código no Arduino.

O código está abaixo ou AQUI, copie o código cole no Arduino IDE e faça a carga.

Este LINK tem as instruções de como carregar um código no Arduino utilizando o Arduino IDE, o código pode ser copiado e colado na tela do Arduno IDE para ser carregado.

Monte o braço em etapas.

Importante: Conforme for montado o braço conecte os servos ao shield para tetar e centralizar os servos, veja o VÍDEO.

Obs: Em algumas versões do SHIELD o pino correspondente ao AREF do arduino deve ser cortado, ela interfere no funcionamento. 

Obs: Caso o kit que possua seja do tipo impresso em 3D com joystick separado, veja a montagem AQUI.

Para conectar os servos ao  shield joystick duplo veja as instruções abaixo:

-  D9 do shield deve ser conectado no servo da Base;

-  D10 do shield deve ser conectado no servo da Garra;

-  D11 do shield deve ser conectado no servo da Altura;

-  D6  do shield deve ser conectado  no servo da Profundidade;

Conecte caga grupo de 3 pinos do servo as saídas do shield correspondentes.

Posição das alavancas do shield em relação aos movimentos do braço;

Código:

#define potGarra        0           // porta A0 Joystick esquerda POT X

#define potBase         1           // porta A1 Joystick esquerda POT Y

#define potAltura       2           // porta A2 Joystick direita  POT X

#define potProfundidade 3           // porta A3 Joystick direita  POT Y

int atraso = 10;                    // atraso de 10 milisegundos

int valorGarra ;

int valorBase ;

int valorAltura ;

int valorProfundidade;

int valorGarraFinal ;

int valorBaseFinal ;

int valorAlturaFinal ;

int valorProfundidadeFinal;

#include <Servo.h>                    // Biblioteca Servo

Servo myservoBase;                    // Objeto servo para controlar a base

Servo myservoGarra;                   // Objeto servo para controlar a garra

Servo myservoAltura;                  // Objeto servo para controlar a altura do braço

Servo myservoProfundidade;            // Objeto servo para profundidade a altura do braço

void setup()

{

  myservoBase.attach(9);              //Associa cada objeto a um pino pwm

  myservoGarra.attach(10);

  myservoAltura.attach(11);

  myservoProfundidade.attach(6);

  Serial.begin(9600);                 // console serial 9600 Bps

  valorBaseFinal = 90;                // valores usados para o controle dos servomotores

  valorAlturaFinal = 90;

  valorProfundidadeFinal = 90;

}

void leituraJoysticks ()

{

  valorGarra = map(analogRead(potGarra), 10, 1000, 179, 0);               // leitura do Joystick POT Garra

  Serial.print(" Valor Garra ="); Serial.println(valorGarra);                      // print Valor Garra 

  valorBase = map(analogRead(potBase), 10, 1000, 0, 179);                   // leitura do Joystick POT Base

  Serial.print(" Valor Base ="); Serial.println(valorBaseFinal);                   // print Valor Base

  valorAltura = map(analogRead(potAltura), 10, 1000, 0, 179);             // leitura do Joystick POT Altura

  Serial.print(" Valor Altura ="); Serial.println(valorAlturaFinal);               // print Valor Altura

  valorProfundidade = map(analogRead(potProfundidade), 10, 1000, 0, 179);  // leitura do Joystick Prof 

  Serial.print(" Valor Profundidade ="); Serial.println(valorProfundidadeFinal);   // print  Profundidade

  Serial.println(); Serial.println();                                              // salta duas linhas

}

void loop()

{

  leituraJoysticks ();                                                             // leitura dos POTs dos Joysticks

  myservoGarra.write(valorGarra);                                      // comando PWM para o servomotor Garra

  if (valorBase > 95)                                                              // se Valor do POT Base > 95

  {

    valorBaseFinal = valorBaseFinal + 1;                                           // incrementa Valor Base

    if (valorBaseFinal > 180) valorBaseFinal = 180;                        // limita Valor Base máximo até 180

    delay (atraso);                                                                // atraso

  }

  if (valorBase < 80)                                                              // se Valor do POT Base < 80

  {

    valorBaseFinal = valorBaseFinal - 1;                                           // decrementa Valor Base

    if (valorBaseFinal < 0) valorBaseFinal = 0;                      // limita Valor Base mínimo até 0

    delay (atraso);                                                                // atraso

  }

  myservoBase.write(valorBaseFinal);                             // comando PWM para o servomotor Base

  if (valorAltura > 95)                                                            // se Valor do POT Altura > 95

  {

    valorAlturaFinal = valorAlturaFinal + 1;                                       // incrementa Valor Altura

    if (valorAlturaFinal > 160) valorAlturaFinal = 160;                      // limita Valor Base máximo até 160

    delay (atraso);                                                                // atraso

  }

  if (valorAltura < 80)                                                            // se Valor do POT Altura < 80

  {

    valorAlturaFinal = valorAlturaFinal - 1;                                       // decrementa Valor Altura

    if (valorAlturaFinal < 30) valorAlturaFinal = 30;                           // limita Valor Base mínimo até 30

    delay (atraso);                                                                // atraso

  }

  myservoAltura.write(valorAlturaFinal);                                           // comando PWM para o servomotor Altura

  if (valorProfundidade > 95)                                                      // se Valor do POT Profundidade > 95

  {

    valorProfundidadeFinal = valorProfundidadeFinal + 1;                    // incrementa Valor Profundidade

    if (valorProfundidadeFinal > 150) valorProfundidadeFinal = 150;        // limita Valor Base a 150

    delay (atraso);                                                                // atraso

  }

  if (valorProfundidade < 80)                                                      // se Valor do POT Profundiade < 80

  {

    valorProfundidadeFinal = valorProfundidadeFinal - 1;                    // decrementa Valor Profundidade

    if (valorProfundidadeFinal < 30) valorProfundidadeFinal = 30;         // limita Valor Base Prof a 30 

    delay (atraso);                                                                // atraso

  }

  myservoProfundidade.write(valorProfundidadeFinal);   // comando PWM para o servo Profundidade

}

_________________________________________________________________________

Para servos de 360º carregue este código:

Baixe a biblioteca VarSpeedServo neste link:

______________________________________________________________________________________

#include <VarSpeedServo.h> // Inclui a Biblioteca VarSpeedServo.h

 

VarSpeedServo servo_sobe; //Cria objeto para controlar o servo sobe

VarSpeedServo servo_frente; //Cria objeto para controlar o servo frente

VarSpeedServo servo_garra; //Cria objeto para controlar o servo garra

VarSpeedServo servo_corpo; //Cria objeto para controlar o servo corpo

 

int pino_x = A0; //Inicializa o pino analógico ao eixo X do joystick

int pino_y = A1; //Inicializa o pino analógico ao eixo Y do joystick

int pino_z = A3; //Inicializa o pino analógico ao eixo Z do joystick

int pino_w = A4; //Inicializa o pino analógico ao eixo W do joystick

int val_x; //Armazena o valor lido pelo eixo X do joystick

int val_y; //Armazena o valor lido pelo eixo Y do joystick

int val_z; //Armazena o valor lido pelo eixo Z do joystick

int val_w; //Armazena o valor lido pelo eixo W do joystick

 

void setup() {

 servo_sobe.attach(9, 1, 180); //Define que o servo está conectado a porta 9 do Arduino

 servo_frente.attach(6, 1, 180); //Define que o servo está conectado a porta 6 do Arduino

 servo_garra.attach(10, 1, 180); //Define que o servo está conectado a porta 10 do Arduino

 servo_corpo.attach(11, 1, 180); //Define que o servo está conectado a porta 11 do Arduino

}

 

void loop() {

 val_x = analogRead(pino_x); //Recebe o valor lido pelo eixo X do joystick

 val_x = map(val_x, 0, 1023, 1, 180); //Converte o valor lido para um valor em graus (1 a 180º)

 servo_sobe.slowmove(val_x, 20); //Movimenta o servo até a posição definida pelo eixo X

 

 val_y = analogRead(pino_y); //Recebe o valor lido pelo eixo Y do joystick

 val_y = map(val_y, 0, 1023, 1, 180); //Converte o valor lido para um valor em graus (1 a 180º)

 servo_frente.slowmove(val_y, 20); //Movimenta o servo até a posição definida pelo eixo Y

 

 val_z = analogRead(pino_z); //Recebe o valor lido pelo eixo Z do joystick

 val_z = map(val_z, 0, 1023, 1, 180); //Converte o valor lido para um valor em graus (1 a 180º)

 servo_garra.slowmove(val_z, 20); //Movimenta o servo até a posição definida pelo eixo Z

 

 val_w = analogRead(pino_w); //Recebe o valor lido pelo eixo W do joystick

 val_w = map(val_w, 0, 1023, 1, 180); //Converte o valor lido para um valor em graus (1 a 180º)

 servo_corpo.slowmove(val_w, 20); //Movimenta o servo até a posição definida pelo eixo W

 

 delay(10);

}

__________________________________________________________________________

Obs: Em algumas versões do SHIELD o pino correspondente ao AREF do arduino deve ser CORTADO no SHIELD, ele interfere no funcionamento. 

Após a montagem teste os comandos, mudanças podem ser feitas para tornar a operação do braço mais adequada ao usuário.

Para um funcionamento melhor um carregador de celular pode ser ligado a USB do Arduino, após a carga do código, já que a USB do computador fornece uma corrente limitada. 

COMPRAR: