# data[].attributes.body
/*
    Componentes usados:
    - Arduino Mega
    - 1 Monster Motor Shield
    - 1 MPU6050 (giroscopio)
    - Código Base Trio
  */

  #include <VirtualWire.h>
  #include <MPU6050_tockn.h>  // biblioteca do giroscopio
  #include <Wire.h>
  #include <AFMotor.h>

  //***********VELOCIDADES************
  #define VELOCIDADE_TOTAL 255 // Velocidade do motor
  #define VELOCIDADE_GIRO 180 // Velocidade do motor
  #define VELOCIDADE_MINIMA 180
  #define VELOCIDADE_MEDIA 200


  char* dados;
  char* dados02;
  MPU6050 mpu6050(Wire);

  int valor = 1;

void setup() {

  //Giroscopio
  Wire.begin();
  mpu6050.begin();

  //Monitor Serial
  Serial.begin(9600);

  // Módulo Radiofrequencia
  vw_set_tx_pin(52); //Pino de dados
  vw_setup(2000); //Velocidade de transmissão em bits por segundo

  dados = "R";
  dados02 = "G";

  // Estado inicial do motor (parado)
  digitalWrite(4, 0);
  digitalWrite(7, 0);
  digitalWrite(8, 0);
  digitalWrite(9, 0);

  delay(1000);

}

void loop() {

  mpu6050.update();
  float angulo = mpu6050.getAngleZ(); // a variavel angulo guarda o angulo que o giroscopio esta lendo
  //Serial.println(angulo);

// ----------------------------------------------------------------------------------
// --------------------| FASE 01: Posicionar no Centro do Palco |-------------------

  if(valor == 1){
    analogWrite(5, VELOCIDADE_MINIMA);
    analogWrite(6, VELOCIDADE_MINIMA);

    mover_frente();
    delay(3000);
    parar();
    delay(3000);
    valor = 2;
  }

  if(valor == 2){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -150){
      parar();
      delay(10000);
      valor = 3;
    }else{
      mover_direita();
    }
  }

// ----------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------
// --------------------| FASE 02: Erguer Corpo + Giros Laterais |-------------------
  if(valor == 3){
    vw_send((uint8_t *)dados, strlen(dados));
    vw_wait_tx(); //Aguarda o envio
    delay(6000);
    valor = 4;
  }

  if(valor == 4){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -200){
      parar();
      delay(1500);
      valor = 5;
    }else{
      mover_direita();
    }
  }

  if(valor == 5){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -100){
      parar();
      delay(1500);
      valor = 6;
    }else{
      mover_esquerda();
    }
  }

  if(valor == 6){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -200){
      parar();
      delay(1500);
      valor = 7;
    }else{
      mover_direita();
    }
  }

  if(valor == 7){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -100){
      parar();
      delay(1500);
      valor = 8;
    }else{
      mover_esquerda();
    }
  }

  if(valor == 8){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -200){
      parar();
      delay(1500);
      valor = 9;
    }else{
      mover_direita();
    }
  }

  if(valor == 9){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -100){
      parar();
      delay(1500);
      valor = 10;
    }else{
      mover_esquerda();
    }
  }

  if(valor == 10){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -200){
      parar();
      delay(1500);
      valor = 11;
    }else{
      mover_direita();
    }
  }

  if(valor == 11){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -100){
      parar();
      delay(1500);
      valor = 12;
    }else{
      mover_esquerda();
    }
  }

  if(valor == 12){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -150){
      parar();
      delay(5000);
      valor = 13;
    }else{
      mover_direita();
    }
  }
// ----------------------------------------------------------------------------------


// ----------------------------------------------------------------------------------------------------------
// --------------------| FASE 03: Giros Laterais e Movimentações Frontais + Posicionamento Central |---------

  if(valor == 13){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -250){
      parar();
      delay(3000);
      valor = 14;
    }else{
      mover_direita();
    }
  }

  if(valor == 14){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_frente();
    delay(2500);
    parar();
    delay(2000);
    valor = 15;
  }

  if(valor == 15){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_tras();
    delay(2500);
    parar();
    delay(2000);
    valor = 16;
  }

  if(valor == 16){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -90){
      parar();
      delay(2000);
      valor = 17;
    }else{
      mover_esquerda();
    }
  }

  if(valor == 17){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_frente();
    delay(2500);
    parar();
    delay(2000);
    valor = 18;
  }

  if(valor == 18){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_tras();
    delay(2500);
    parar();
    delay(2000);
    valor = 19;
  }

  if(valor == 19){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -150){
      parar();
      delay(5000);
      valor = 20;
    }else{
      mover_direita();
    }
  }
// ----------------------------------------------------------------------------------------------------------


// -------------------------------------------------------------------------------
// --------------------| FASE 04: Giro 360° + Posicionamento Frontal |-----------
  if(valor == 20){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -600){
      parar();
      delay(4000);
      valor = 21;
    }else{
      mover_direita();
    }
  }

  if(valor == 21){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -150){
      parar();
      delay(17000);
      valor = 22;
    }else{
      mover_esquerda();
    }
  }
// -------------------------------------------------------------------------------


// -------------------------------------------------------------------------------
// --------------------| FASE 05: Espera de 17s + Baixar Corpo |------------------

  if(valor == 22){
    vw_send((uint8_t *)dados02, strlen(dados02));
    vw_wait_tx(); //Aguarda o envio
    delay(10000);
    valor = 23;
  }

// -------------------------------------------------------------------------------


// -------------------------------------------------------------------------------
// --------------------| FASE 06: Movimentação Frente e Tras |--------------------

  if(valor == 23){
    analogWrite(5, VELOCIDADE_MEDIA);
    analogWrite(6, VELOCIDADE_MEDIA);

    mover_frente();
    delay(2000);
    parar();
    delay(3000);
    valor = 24;
  }

  if(valor == 24){
    analogWrite(5, VELOCIDADE_MEDIA);
    analogWrite(6, VELOCIDADE_MEDIA);

    mover_tras();
    delay(2000);
    parar();
    delay(3000);
    valor = 25;
  }

    if(valor == 25){
    analogWrite(5, VELOCIDADE_MEDIA);
    analogWrite(6, VELOCIDADE_MEDIA);

    mover_frente();
    delay(2000);
    parar();
    delay(3000);
    valor = 26;
  }

  if(valor == 26){
    analogWrite(5, VELOCIDADE_MEDIA);
    analogWrite(6, VELOCIDADE_MEDIA);

    mover_tras();
    delay(2000);
    parar();
    delay(3000);
    valor = 27;
  }

  if(valor == 27){
    analogWrite(5, VELOCIDADE_MEDIA);
    analogWrite(6, VELOCIDADE_MEDIA);

    mover_frente();
    delay(2000);
    parar();
    delay(3000);
    valor = 28;
  }

  if(valor == 28){
    analogWrite(5, VELOCIDADE_MEDIA);
    analogWrite(6, VELOCIDADE_MEDIA);

    mover_tras();
    delay(2000);
    parar();
    delay(3000);
    valor = 29;
  }

    if(valor == 29){
    analogWrite(5, VELOCIDADE_MEDIA);
    analogWrite(6, VELOCIDADE_MEDIA);

    mover_frente();
    delay(2000);
    parar();
    delay(3000);
    valor = 30;
  }

  if(valor == 30){
    analogWrite(5, VELOCIDADE_MEDIA);
    analogWrite(6, VELOCIDADE_MEDIA);

    mover_tras();
    delay(2000);
    parar();
    delay(3000);
    valor = 31;
  }
// -------------------------------------------------------------------------------

}

// -------------------------------------------------------------------------------
// --------------------------| FUNÇÕES DE MOVIMENTO |-----------------------------
  void mover_frente(){
    // motor 02
    digitalWrite(7, 0);
    digitalWrite(8, 1);

    // motor 01
    digitalWrite(4, 0);
    digitalWrite(9, 1);
  }

  void mover_tras(){
    // motor 02
    digitalWrite(7, 1);
    digitalWrite(8, 0);

    //motor 01
    digitalWrite(4, 1);
    digitalWrite(9, 0);
  }

  void parar(){
    //motor 02
    digitalWrite(7, 0);
    digitalWrite(8, 0);

    //motor 01
    digitalWrite(4, 0);
    digitalWrite(9, 0);
  }

  void mover_direita(){
  // motor 02
    digitalWrite(7, 0);
    digitalWrite(8, 1);

    // motor 01
    digitalWrite(4, 1);
    digitalWrite(9, 0);
  }


  void mover_esquerda(){
  // motor 02
    digitalWrite(7, 1);
    digitalWrite(8, 0);

    // motor 01
    digitalWrite(4, 0);
    digitalWrite(9, 1);
  }
// -------------------------------------------------------------------------------

# data[].attributes.body
  /*
    Componentes usados:
    - Arduino Mega
    - 2 sensores de campo magnético
    - 1 Monster Motor Shield
    - Código Erguer Corpo
  */

  #include <VirtualWire.h>

  #define VELOCIDADE_subida 100     // Velocidade do motor para erguer o corpo
  #define VELOCIDADE_descida 200    // Velocidade do motor para descer o corpo
  #define s1_baixo 53               // Sensor Magnético 01
  #define s1_alto 51                // Sensor Magnético 02
  #define s2_baixo 52
  #define s2_alto 50

  int rotina = 999;

void setup() {
  Serial.begin(9600); // Inicia a comunicação serial

  // Módulo Radiofrequência
  vw_set_rx_pin(49);
  vw_setup(2000);
  vw_rx_start();

  // Sensores de Campo Magnético
  pinMode(s1_alto, INPUT);
  pinMode(s1_baixo, INPUT);
  pinMode(s2_alto, INPUT);
  pinMode(s2_baixo, INPUT);

  // Estado inicial do motor (parado)
  digitalWrite(4, 0);
  digitalWrite(7, 0);
  digitalWrite(8, 0);
  digitalWrite(9, 0);
}

void loop(){
  // Ler valores dos sensores
  bool sensor1_alto = digitalRead(s1_alto);
  bool sensor1_baixo = digitalRead(s1_baixo);

  bool sensor2_alto = digitalRead(s2_alto);
  bool sensor2_baixo = digitalRead(s2_baixo);

  uint8_t dados[VW_MAX_MESSAGE_LEN];
  uint8_t tamanho_dados = VW_MAX_MESSAGE_LEN;

  Serial.println(dados[0]);

  if (vw_get_message(dados, &tamanho_dados)) {
    if (dados[0] == 'R' || dados[0] == '82' || dados[0] == 82) {
      Serial.write(dados[0]);
      rotina = 0;
    }

    if (dados[0] == 'G' || dados[0] == '71' || dados[0] == 71) {
      Serial.write(dados[0]);
      rotina = 1;
    }
  }

  if (rotina == 0) { // ANGULO = 180°
    analogWrite(5, VELOCIDADE_subida);
    analogWrite(6, VELOCIDADE_subida);

    if (sensor1_alto == true || sensor2_alto == true) {
      digitalWrite(7, 0);
      digitalWrite(8, 0);
      digitalWrite(4, 0);
      digitalWrite(9, 0);
      Serial.println("Etapa 01 - 45°");
      delay(2000);
    }else {
      digitalWrite(7, 0);
      digitalWrite(8, 1);
      digitalWrite(4, 0);
      digitalWrite(9, 1);
    }
  }

  if (rotina == 1) { // ANGULO = 90°
    analogWrite(5, VELOCIDADE_descida);
    analogWrite(6, VELOCIDADE_descida);

    if (sensor1_baixo == true || sensor2_baixo == true) {
      digitalWrite(7, 0);
      digitalWrite(8, 0);
      digitalWrite(4, 0);
      digitalWrite(9, 0);

      Serial.println("Etapa 02 - 90°");

      delay(2000);
    } else {
      digitalWrite(7, 1);
      digitalWrite(8, 0);
      digitalWrite(4, 1);
      digitalWrite(9, 0);
    }
  }
}

# data[].attributes.body
/*
    Componentes usados:
    - Arduino Mega
    - 1 Monster Motor Shield
    - 1 MPU6050 (giroscopio)
    - Código Base Trio
  */

  #include <VirtualWire.h>
  #include <MPU6050_tockn.h>  // biblioteca do giroscopio
  #include <Wire.h>
  #include <AFMotor.h>

  //***********VELOCIDADES************
  #define VELOCIDADE_TOTAL 255 // Velocidade do motor
  #define VELOCIDADE_GIRO 180 // Velocidade do motor
  #define VELOCIDADE_MINIMA 180

  //***********ANGULOS************


  char* dados;
  MPU6050 mpu6050(Wire);

  int valor = 1;

void setup() {

  //Giroscopio
  Wire.begin();
  mpu6050.begin();

  //Monitor Serial
  Serial.begin(9600);

  // Módulo Radiofrequencia
  vw_set_tx_pin(52); //Pino de dados
  vw_setup(2000); //Velocidade de transmissão em bits por segundo
  dados = "R";
  // Estado inicial do motor (parado)
  digitalWrite(4, 0);
  digitalWrite(7, 0);
  digitalWrite(8, 0);
  digitalWrite(9, 0);

  delay(1000);

}

void loop() {

  mpu6050.update();
  float angulo = mpu6050.getAngleZ(); // a variavel angulo guarda o angulo que o giroscopio esta lendo
  //Serial.println(angulo);

// ___________________________________________________
// ___________________ FASE 01: 16s __________________

  if(valor == 1){
    analogWrite(5, VELOCIDADE_MINIMA);
    analogWrite(6, VELOCIDADE_MINIMA);

    mover_frente();
    delay(3000);
    parar();
    delay(3000);
    valor = 2;
  }

  if(valor == 2){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -150){
      parar();
      delay(10000);
      valor = 3;
    }else{
      mover_direita();
    }
  }

// ___________________________________________________
// ___________________ FASE 02: 23s __________________

  if(valor == 3){
    vw_send((uint8_t *)dados, strlen(dados));
    vw_wait_tx(); //Aguarda o envio
    delay(6000);
    valor = 4;

  }

  if(valor == 4){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -200){
      parar();
      delay(1500);
      valor = 5;
    }else{
      mover_direita();
    }
  }

  if(valor == 5){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -100){
      parar();
      delay(1500);
      valor = 6;
    }else{
      mover_esquerda();
    }
  }

  if(valor == 6){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -200){
      parar();
      delay(1500);
      valor = 7;
    }else{
      mover_direita();
    }
  }

  if(valor == 7){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -100){
      parar();
      delay(1500);
      valor = 8;
    }else{
      mover_esquerda();
    }
  }
//*******************************
  if(valor == 8){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -200){
      parar();
      delay(1500);
      valor = 9;
    }else{
      mover_direita();
    }
  }

  if(valor == 9){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -100){
      parar();
      delay(1500);
      valor = 10;
    }else{
      mover_esquerda();
    }
  }

  if(valor == 10){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -200){
      parar();
      delay(1500);
      valor = 11;
    }else{
      mover_direita();
    }
  }

  if(valor == 11){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -100){
      parar();
      delay(1500);
      valor = 12;
    }else{
      mover_esquerda();
    }
  }

//*******************************

  if(valor == 12){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -150){
      parar();
      delay(5000);
      valor = 13;
    }else{
      mover_direita();
    }
  }

// ___________________________________________________
// _____________________ FASE 03 _____________________

  if(valor == 13){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -250){
      parar();
      delay(3000);
      valor = 14;
    }else{
      mover_direita();
    }
  }

  if(valor == 14){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_frente();
    delay(2500);
    parar();
    delay(2000);
    valor = 15;
  }

  if(valor == 15){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_tras();
    delay(2500);
    parar();
    delay(2000);
    valor = 16;
  }

  if(valor == 16){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -90){
      parar();
      delay(2000);
      valor = 17;
    }else{
      mover_esquerda();
    }
  }

  if(valor == 17){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_frente();
    delay(2500);
    parar();
    delay(2000);
    valor = 18;
  }

  if(valor == 18){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_tras();
    delay(2500);
    parar();
    delay(2000);
    valor = 19;
  }

  if(valor == 19){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -150){
      parar();
      delay(5000);
      valor = 99;
    }else{
      mover_direita();
    }
  }

// ___________________________________________________
// _____________________ FASE 04 _____________________

  if(valor == 20){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_tras();
    delay(2500);
    parar();
    delay(2000);
    valor = 21;
  }



}

// ________________________________________________________________
// _____________________ FUNÇÕES DE MOVIMENTO _____________________

void mover_frente(){
  // motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 1);

  // motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 1);

}

void mover_tras(){
  // motor 02
  digitalWrite(7, 1);
  digitalWrite(8, 0);

  //motor 01
  digitalWrite(4, 1);
  digitalWrite(9, 0);

}

void parar(){
  //motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 0);

  //motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 0);

}

void mover_direita(){
 // motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 1);

  // motor 01
  digitalWrite(4, 1);
  digitalWrite(9, 0);

}


void mover_esquerda(){
 // motor 02
  digitalWrite(7, 1);
  digitalWrite(8, 0);

  // motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 1);

}

# data[].attributes.body
/*
    Componentes usados:
    - Arduino Mega
    - 1 Monster Motor Shield
    - 1 MPU6050 (giroscopio)
    - Código Base Trio
  */

  #include <VirtualWire.h>
  #include <MPU6050_tockn.h>  // biblioteca do giroscopio
  #include <Wire.h>
  #include <AFMotor.h>

  //***********VELOCIDADES************
  #define VELOCIDADE_TOTAL 255 // Velocidade do motor
  #define VELOCIDADE_GIRO 200 // Velocidade do motor

  //***********ANGULOS************


  char* dados;
  MPU6050 mpu6050(Wire);

  int valor = 1;

void setup() {

  //Giroscopio
  Wire.begin();
  mpu6050.begin();

  //Monitor Serial
  Serial.begin(9600);

  // Módulo Radiofrequencia
  vw_set_tx_pin(52); //Pino de dados
  vw_setup(2000); //Velocidade de transmissão em bits por segundo
  dados = "R";
  // Estado inicial do motor (parado)
  digitalWrite(4, 0);
  digitalWrite(7, 0);
  digitalWrite(8, 0);
  digitalWrite(9, 0);

  delay(2000);

}

void loop() {

  mpu6050.update();
  float angulo = mpu6050.getAngleZ(); // a variavel angulo guarda o angulo que o giroscopio esta lendo
  //Serial.println(angulo);

// ___________________________________________________
// _____________________ FASE 01 _____________________

  if(valor == 1){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_frente();
    delay(2500);
    parar();
    delay(2000);
    valor = 2;
  }

  if(valor == 2){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -150){
      parar();
      delay(2000);
      valor = 3;
    }else{
      mover_direita();
    }
  }

// ___________________________________________________
// _____________________ FASE 02 _____________________

  if(valor == 3){
    vw_send((uint8_t *)dados, strlen(dados));
    vw_wait_tx(); //Aguarda o envio
    delay(4000);
    valor = 4;

  }

  if(valor == 4){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -200){
      parar();
      delay(2000);
      valor = 5;
    }else{
      mover_direita();
    }
  }

  if(valor == 5){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -100){
      parar();
      delay(2000);
      valor = 6;
    }else{
      mover_esquerda();
    }
  }

  if(valor == 6){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -200){
      parar();
      delay(2000);
      valor = 7;
    }else{
      mover_direita();
    }
  }

  if(valor == 7){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -100){
      parar();
      delay(2000);
      valor = 8;
    }else{
      mover_esquerda();
    }
  }

  if(valor == 8){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -150){
      parar();
      delay(2000);
      valor = 9;
    }else{
      mover_direita();
    }
  }

// ___________________________________________________
// _____________________ FASE 03 _____________________

  if(valor == 9){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo < -200){
      parar();
      delay(2000);
      valor = 10;
    }else{
      mover_direita();
    }
  }

  if(valor == 10){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_frente();
    delay(2500);
    parar();
    delay(2000);
    valor = 11;
  }

  if(valor == 11){
    analogWrite(5, VELOCIDADE_GIRO);
    analogWrite(6, VELOCIDADE_GIRO);

    if(angulo > -100){
      parar();
      delay(2000);
      valor = 12;
    }else{
      mover_esquerda();
    }
  }

  if(valor == 12){
    analogWrite(5, VELOCIDADE_TOTAL);
    analogWrite(6, VELOCIDADE_TOTAL);

    mover_frente();
    delay(4000);
    parar();
    delay(2000);
    valor = 13;
  }
}

void mover_frente(){
  // motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 1);

  // motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 1);

}

void mover_tras(){
  // motor 02
  digitalWrite(7, 1);
  digitalWrite(8, 0);

  //motor 01
  digitalWrite(4, 1);
  digitalWrite(9, 0);

}

void parar(){
  //motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 0);

  //motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 0);

}

void mover_direita(){
 // motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 1);

  // motor 01
  digitalWrite(4, 1);
  digitalWrite(9, 0);

}


void mover_esquerda(){
 // motor 02
  digitalWrite(7, 1);
  digitalWrite(8, 0);

  // motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 1);

}

# data[].attributes.body
/*
  Componentes usados:
  - Arduino Mega
  - 2 sensores de campo magnético
  - 1 Monster Motor Shield
  - Código Erguer Corpo
*/

#include <VirtualWire.h>

#define VELOCIDADE_subida 100     // Velocidade do motor para erguer o corpo
#define VELOCIDADE_descida 200    // Velocidade do motor para descer o corpo
#define s1_baixo 53                // Sensor Magnético 01
#define s1_alto 51                 // Sensor Magnético 02
#define s2_baixo 52
#define s2_alto 50

int rotina = 999;

void setup() {
  Serial.begin(9600); // Inicia a comunicação serial

  // Módulo Radiofrequência
  vw_set_rx_pin(49);
  vw_setup(2000);
  vw_rx_start();

  // Sensores de Campo Magnético
  pinMode(s1_alto, INPUT);
  pinMode(s1_baixo, INPUT);
  pinMode(s2_alto, INPUT);
  pinMode(s2_baixo, INPUT);

  // Estado inicial do motor (parado)
  digitalWrite(4, 0);
  digitalWrite(7, 0);
  digitalWrite(8, 0);
  digitalWrite(9, 0);
}

void loop() {
  // Ler valores dos sensores
  bool sensor1_alto = digitalRead(s1_alto);
  bool sensor1_baixo = digitalRead(s1_baixo);

  bool sensor2_alto = digitalRead(s2_alto);
  bool sensor2_baixo = digitalRead(s2_baixo);

  uint8_t dados[VW_MAX_MESSAGE_LEN];
  uint8_t tamanho_dados = VW_MAX_MESSAGE_LEN;

  Serial.println(dados[0]);

  if (vw_get_message(dados, &tamanho_dados)) {
    if (dados[0] == 'R') {
      Serial.write(dados[0]);
      rotina = 0;
    }
  }

  if (rotina == 0) { // ANGULO = 180°
    analogWrite(5, VELOCIDADE_subida);
    analogWrite(6, VELOCIDADE_subida);

    if (sensor1_alto == true || sensor2_alto == true) {
      digitalWrite(7, 0);
      digitalWrite(8, 0);
      digitalWrite(4, 0);
      digitalWrite(9, 0);

      Serial.println("Etapa 01 - 45°");

      delay(2000);
      rotina = 1;
    } else {
      digitalWrite(7, 0);
      digitalWrite(8, 1);
      digitalWrite(4, 0);
      digitalWrite(9, 1);
    }
  }
/*
  if (rotina == 1) { // ANGULO = 90°
    analogWrite(5, VELOCIDADE_descida);
    analogWrite(6, VELOCIDADE_descida);

    if (sensor1_baixo == true || sensor2_baixo == true) {
      digitalWrite(7, 0);
      digitalWrite(8, 0);
      digitalWrite(4, 0);
      digitalWrite(9, 0);

      Serial.println("Etapa 02 - 90°");

      delay(2000);
      rotina = 777;
    } else {
      digitalWrite(7, 0);
      digitalWrite(8, 1);
      digitalWrite(4, 0);
      digitalWrite(9, 1);
    }
  }
*/
}

# data[].attributes.body
/*

Componentes usados:

- Arduino Mega

- 1 Monster Motor Shield

- Código Base Trio

*/

#include <VirtualWire.h>

#define VELOCIDADE 200 // Velocidade do motor

char* dados;

void setup() {

// Módulo Radiofrequencia

vw_set_tx_pin(53); //Pino de dados

vw_setup(2000); //Velocidade de transmissão em bits por segundo

dados = "R";

// Estado inicial do motor (parado)

digitalWrite(4, 0);

digitalWrite(7, 0);

digitalWrite(8, 0);

digitalWrite(9, 0);

// Velocidade Motor

analogWrite(5, VELOCIDADE);

analogWrite(6, VELOCIDADE);

}

void loop() {

mover_frente();

delay(4000);

parar();

delay(2000);

mover_tras();

delay(4000);

parar();

delay(2000);

vw_send((uint8_t *)dados, strlen(dados));

vw_wait_tx(); //Aguarda o envio

delay(20000);

}

void mover_frente(){

// motor 02

digitalWrite(7, 0);

digitalWrite(8, 1);

// motor 01

digitalWrite(4, 0);

digitalWrite(9, 1);

}

void mover_tras(){

// motor 02

digitalWrite(7, 1);

digitalWrite(8, 0);

//motor 01

digitalWrite(4, 1);

digitalWrite(9, 0);

}

void parar(){

//motor 02

digitalWrite(7, 0);

digitalWrite(8, 0);

//motor 01

digitalWrite(4, 0);

digitalWrite(9, 0);

}

void mover_direita(){

// motor 02

digitalWrite(7, 0);

digitalWrite(8, 1);

// motor 01

digitalWrite(4, 1);

digitalWrite(9, 0);

}

void mover_esquerda(){

// motor 02

digitalWrite(7, 1);

digitalWrite(8, 0);

// motor 01

digitalWrite(4, 0);

digitalWrite(9, 1);

}

# data[].attributes.body
usar essa estrutura para fazer o braco

# data[].attributes.body
a. Estrutura física do robô

Apresentação Completa do Robô: Vídeo e Fotos

Apresentação dos Sistemas do Robô: Base e Corpo

b. Inspiração do Design do Robô: Fubica

c. Apresentação do sistema 01: base trio

Todos os Componentes

Estrutura

Estratégias de Construção

d. Apresentação do sistema 02: corpo

Todos os Componentes

Estrutura

Estratégias de Construção

e. Comunicação entre sistema 01 e sistema 02

porque os sistemas devem se comunicar

problema encontrado

solução encontrada

# data[].attributes.body
/*
  Componentes usados:
  - Arduino Mega
  - 2 sensores de campo magnético
  - 1 Monster Motor Shield
  - Código Erguer Corpo
*/

#include <VirtualWire.h>
#include <HCSR04.h> // Biblioteca do sensor ultrassônico

#define VELOCIDADE_subida 100     // Velocidade do motor para erguer o corpo
#define VELOCIDADE_descida 200    // Velocidade do motor para descer o corpo
#define s1_baixo 53                // Sensor Magnético 01
#define s1_alto 51                 // Sensor Magnético 02
#define s2_baixo 52
#define s2_alto 50

int rotina = 7;

void setup() {
  Serial.begin(9600); // Inicia a comunicação serial

  // Módulo Radiofrequência
  vw_set_rx_pin(49);
  vw_setup(2000);
  vw_rx_start();

  // Sensores de Campo Magnético
  pinMode(s1_alto, INPUT);
  pinMode(s1_baixo, INPUT);
  pinMode(s2_alto, INPUT);
  pinMode(s2_baixo, INPUT);

  // Estado inicial do motor (parado)
  digitalWrite(4, 0);
  digitalWrite(7, 0);
  digitalWrite(8, 0);
  digitalWrite(9, 0);
}

void loop() {
  // Ler valores dos sensores
  bool sensor1_alto = digitalRead(s1_alto);
  bool sensor1_baixo = digitalRead(s1_baixo);

  bool sensor2_alto = digitalRead(s2_alto);
  bool sensor2_baixo = digitalRead(s2_baixo);

  uint8_t dados[VW_MAX_MESSAGE_LEN];
  uint8_t tamanho_dados = VW_MAX_MESSAGE_LEN;

  if (vw_get_message(dados, &tamanho_dados)) {
    if (dados[0] == 'R') {
      Serial.write(dados[0]);
      rotina = 0;
    }
  }

  if (rotina == 0) { // ANGULO = 180°
    analogWrite(5, VELOCIDADE_subida);
    analogWrite(6, VELOCIDADE_subida);

    if (sensor1_alto == true || sensor2_alto == true) {
      digitalWrite(7, 0);
      digitalWrite(8, 0);
      digitalWrite(4, 0);
      digitalWrite(9, 0);

      Serial.println("Etapa 01 - 45°");

      delay(2000);
      rotina = 1;
    } else {
      digitalWrite(7, 0);
      digitalWrite(8, 1);
      digitalWrite(4, 0);
      digitalWrite(9, 1);
    }
  }

  if (rotina == 1) { // ANGULO = 90°
    analogWrite(5, VELOCIDADE_descida);
    analogWrite(6, VELOCIDADE_descida);

    if (sensor1_baixo == true || sensor2_baixo == true) {
      digitalWrite(7, 0);
      digitalWrite(8, 0);
      digitalWrite(4, 0);
      digitalWrite(9, 0);

      Serial.println("Etapa 02 - 90°");

      delay(2000);
      rotina = 777;
    } else {
      digitalWrite(7, 1);
      digitalWrite(8, 0);
      digitalWrite(4, 1);
      digitalWrite(9, 0);
    }
  }

  delay(500);
}

# data[].attributes.body
/*
  Componentes usados:
  - Arduino Mega
  - 2 sensores de campo magnético
  - 1 Monster Motor Shield
*/

#include <HCSR04.h> // Biblioteca do sensor ultrassônico

#define VELOCIDADE_subida 100 // Velocidade do motor para erguer o corpo
#define VELOCIDADE_descida 200 // Velocidade do motor para descer o corpo
#define s_baixo 53 // Sensor Magnético 01
#define s_alto 51 // Sensor Magnético 02
#define SINAL 49

int rotina = 7;

void setup() {

    Serial.begin(9600); // Inicia a comunicação serial

    pinMode(s_alto,INPUT);
    pinMode(s_baixo,INPUT);
    pinMode(SINAL,INPUT);

    // Estado inicial do motor (parado)
    digitalWrite(4, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
    digitalWrite(9, 0);

}

void loop() {
    // Ler valores dos sensores
    bool sensor_alto = digitalRead(s_alto);
    bool sensor_baixo = digitalRead(s_baixo);

    if(digitalRead(SINAL)==HIGH){
      rotina = 0;
    }

    if(rotina == 0){ // ANGULO = 180°

      analogWrite(5, VELOCIDADE_subida);
      analogWrite(6, VELOCIDADE_subida);

      if(sensor_alto == true) {
        digitalWrite(7, 0);
        digitalWrite(8, 0);
        digitalWrite(4, 0);
        digitalWrite(9, 0);

        Serial.println("Etapa 01 - 45°");

        delay(2000);

        rotina = 1;

      }else{
        digitalWrite(7, 0);
        digitalWrite(8, 1);
        digitalWrite(4, 0);
        digitalWrite(9, 1);
      }

    }

    if(rotina == 1){ // ANGULO = 90°

      analogWrite(5, VELOCIDADE_descida);
      analogWrite(6, VELOCIDADE_descida);

      if(sensor_baixo == true ) {
        digitalWrite(7, 0);
        digitalWrite(8, 0);
        digitalWrite(4, 0);
        digitalWrite(9, 0);

        Serial.println("Etapa 02 - 90°");

        delay(2000);

        rotina = 666;

      }else{
        digitalWrite(7, 1);
        digitalWrite(8, 0);
        digitalWrite(4, 1);
        digitalWrite(9, 0);
      }

    }
    delay(500);
}

# data[].attributes.body
/*
  Componentes usados:
  - Arduino Mega
  - 1 Monster Motor Shield
*/
#define VELOCIDADE 200 // Velocidade do motor
#define SINAL 53

void setup() {

    // Estado inicial do motor (parado)
    digitalWrite(4, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
    digitalWrite(9, 0);

    // Sinal
    pinMode(SINAL,OUTPUT);

    // Velocidade Motor
    analogWrite(5, VELOCIDADE);
    analogWrite(6, VELOCIDADE);

}

void loop() {

  mover_frente();
  delay(4000);

  parar();
  delay(2000);

  mover_tras();
  delay(4000);

  parar();
  delay(2000);

  digitalWrite(SINAL,HIGH);

}

void mover_frente(){
  // motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 1);

  // motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 1);

}

void mover_tras(){
  // motor 02
  digitalWrite(7, 1);
  digitalWrite(8, 0);

  //motor 01
  digitalWrite(4, 1);
  digitalWrite(9, 0);

}

void parar(){
  //motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 0);

  //motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 0);

}

void mover_direita(){
 // motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 1);

  // motor 01
  digitalWrite(4, 1);
  digitalWrite(9, 0);

}


void mover_esquerda(){
 // motor 02
  digitalWrite(7, 1);
  digitalWrite(8, 0);

  // motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 1);

}

# data[].attributes.body
/*
  Componentes usados:
  - Arduino Mega
  - 1 Monster Motor Shield
*/
#define VELOCIDADE 200 // Velocidade do motor

void setup() {

    // Estado inicial do motor (parado)
    digitalWrite(4, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
    digitalWrite(9, 0);

    analogWrite(5, VELOCIDADE);
    analogWrite(6, VELOCIDADE);

}

void loop() {

  mover_frente();
  delay(4000);

  parar();
  delay(2000);

  mover_tras();
  delay(4000);

  parar();
  delay(2000);

  mover_direita();
  delay(3000);

  parar();
  delay(2000);

  mover_esquerda();
  delay(3000);

  parar();
  delay(2000);
}

void mover_frente(){
  // motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 1);

  // motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 1);

}

void mover_tras(){
  // motor 02
  digitalWrite(7, 1);
  digitalWrite(8, 0);

  //motor 01
  digitalWrite(4, 1);
  digitalWrite(9, 0);

}

void parar(){
  //motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 0);

  //motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 0);

}

void mover_direita(){
 // motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 1);

  // motor 01
  digitalWrite(4, 1);
  digitalWrite(9, 0);

}


void mover_esquerda(){
 // motor 02
  digitalWrite(7, 1);
  digitalWrite(8, 0);

  // motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 1);

}

# data[].attributes.headline
Código Atualizado Trior - Erguer Corpo Trio

# data[].attributes.subject
Código Atualizado Trior - Erguer Corpo Trio

# data[].attributes.body
/*
  Componentes usados:
  - Arduino Mega
  - 2 sensores de campo magnético
  - 1 Monster Motor Shield
*/

#include <HCSR04.h> // Biblioteca do sensor ultrassônico

#define VELOCIDADE_subida 100 // Velocidade do motor para erguer o corpo
#define VELOCIDADE_descida 200 // Velocidade do motor para descer o corpo
#define s_baixo 53 // Sensor Magnético 01
#define s_alto 51 // Sensor Magnético 02

int rotina = 0;

void setup() {

    Serial.begin(9600); // Inicia a comunicação serial

    pinMode(s_alto,INPUT);
    pinMode(s_baixo,INPUT);

    // Estado inicial do motor (parado)
    digitalWrite(4, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
    digitalWrite(9, 0);

}

void loop() {
    // Ler valores dos sensores
    bool sensor_alto = digitalRead(s_alto);
    bool sensor_baixo = digitalRead(s_baixo);

    if(rotina == 0){ // ANGULO = 180°

      analogWrite(5, VELOCIDADE_subida);
      analogWrite(6, VELOCIDADE_subida);

      if(sensor_alto == true) {
        digitalWrite(7, 0);
        digitalWrite(8, 0);
        digitalWrite(4, 0);
        digitalWrite(9, 0);

        Serial.println("Etapa 01 - 45°");

        delay(2000);

        rotina = 1;

      }else{
        digitalWrite(7, 0);
        digitalWrite(8, 1);
        digitalWrite(4, 0);
        digitalWrite(9, 1);
      }

    }

    if(rotina == 1){ // ANGULO = 90°

      analogWrite(5, VELOCIDADE_descida);
      analogWrite(6, VELOCIDADE_descida);

      if(sensor_baixo == true ) {
        digitalWrite(7, 0);
        digitalWrite(8, 0);
        digitalWrite(4, 0);
        digitalWrite(9, 0);

        Serial.println("Etapa 02 - 90°");

        delay(2000);

        rotina = 0;

      }else{
        digitalWrite(7, 1);
        digitalWrite(8, 0);
        digitalWrite(4, 1);
        digitalWrite(9, 0);
      }

    }
    delay(500);
}

# data[].attributes.body
//B1T A B1T
//www.youtube.com.br/bitabit

//Receptor geral: recebe qualquer dados e printa na serial
//Utilizando o módulo RF

#include <VirtualWire.h>

void setup()
{
  Serial.begin(9600);

  vw_set_rx_pin(53); //Pino de dados
  vw_setup(2000); //Velocidade de recebimento em bits por segundo
  vw_rx_start(); //Inicializa o receptor
}

void loop()
{
  uint8_t dados[VW_MAX_MESSAGE_LEN]; //Armazena os dados recebidos
  uint8_t tamanho_dados = VW_MAX_MESSAGE_LEN; //Armazena o tamanho dos dados

  if(vw_get_message(dados, &tamanho_dados))
  {
    Serial.write(dados[0]);
  }
}

# data[].attributes.body
//B1T A B1T
//www.youtube.com.br/bitabit

//Transmissor de caracteres
//Utilizando o módulo RF

#include <VirtualWire.h>

char* dados;

void setup()
{
  vw_set_tx_pin(53); //Pino de dados
  vw_setup(2000); //Velocidade de transmissão em bits por segundo

  dados = "R";
}

void loop()
{
  if(dados == "R"){
    dados = "r";
  }else{
    dados = "R";
  }
  vw_send((uint8_t *)dados, strlen(dados));
  vw_wait_tx(); //Aguarda o envio

  delay(1000);
}

# data[].attributes.body
/*
  Componentes usados:
  - Arduino Mega
  - 1 Monster Motor Shield
*/

#define VELOCIDADE 100 // Velocidade do motor

void setup() {

    // Estado inicial do motor (parado)
    digitalWrite(4, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
    digitalWrite(9, 0);

    analogWrite(5, VELOCIDADE);
    analogWrite(6, VELOCIDADE);

}

void loop() {

  mover_frente();
  delay(1000);

  parar();
  delay(2000);

  mover_direita();
  delay(5000);

  parar();
  delay(2000);
}

void mover_frente(){
  // motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 1);

  // motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 1);

}

void mover_tras(){
  // motor 02
  digitalWrite(7, 1);
  digitalWrite(8, 0);

  //motor 01
  digitalWrite(4, 1);
  digitalWrite(9, 0);

}

void parar(){
  //motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 0);

  //motor 01
  digitalWrite(4, 0);
  digitalWrite(9, 0);

}

void mover_direita(){
 // motor 02
  digitalWrite(7, 0);
  digitalWrite(8, 1);

  // motor 01
  digitalWrite(4, 1);
  digitalWrite(9, 0);

}

# data[].attributes.body
/*
  Componentes usados:
  - Arduino Mega
  - 2 sensores ultrassônicos
  - 1 Monster Motor Shield
*/

#include <HCSR04.h> // Biblioteca do sensor ultrassônico

// Definição dos pinos dos sensores
UltraSonicDistanceSensor sensor1(52, 53); // Sensor superior
UltraSonicDistanceSensor sensor2(50, 51); // Sensor inferior

#define VELOCIDADE 50 // Velocidade do motor

int rotina = 0;

void setup() {
    Serial.begin(9600); // Inicia a comunicação serial

    // Estado inicial do motor (parado)
    digitalWrite(4, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
    digitalWrite(9, 0);

    analogWrite(5, VELOCIDADE);
    analogWrite(6, VELOCIDADE);

}

void loop() {
    // Ler valores dos sensores
    float sensor_alto = sensor1.measureDistanceCm();
    float sensor_baixo = sensor2.measureDistanceCm();

    // Mostrar leituras no monitor serial
    Serial.print("Sensor alto: ");
    Serial.println(sensor_alto);
    Serial.print("Sensor baixo: ");
    Serial.println(sensor_baixo);

    // Subir até que o sensor superior detecte distância < 10cm
    if(rotina == 0){

      if(sensor_alto < 10) {
        digitalWrite(7, 0);
        digitalWrite(8, 0);
        digitalWrite(4, 0);
        digitalWrite(9, 0);

        delay(2000);

        rotina = 1;

      }else{
        digitalWrite(7, 0);
        digitalWrite(8, 1);
        digitalWrite(4, 0);
        digitalWrite(9, 1);
      }

    }

    if(rotina == 1){

      if(sensor_baixo < 5) {
        digitalWrite(7, 0);
        digitalWrite(8, 0);
        digitalWrite(4, 0);
        digitalWrite(9, 0);

        delay(2000);

        rotina = 0;
      }else{
        digitalWrite(7, 1);
        digitalWrite(8, 0);
        digitalWrite(4, 1);
        digitalWrite(9, 0);
      }
    }
    delay(300);
}

# data[].attributes.body
#include <HCSR04.h> // biblioteca sensor ultrassinico

UltraSonicDistanceSensor sensor1(52,53);
UltraSonicDistanceSensor sensor2(50,51);

#define velocidade 150

void setup()
{

  digitalWrite(4,0);
  digitalWrite(7,0);
  digitalWrite(8,0);
  digitalWrite(9,0);

// velocidade
  analogWrite(5,velocidade);
  analogWrite(6,velocidade);


}

void loop() {

  float sensor_alto = sensor1.measureDistanceCm();
  float sensor_baixo = sensor2.measureDistanceCm();

  if(sensor_alto > 10){

    digitalWrite(7,0);
    digitalWrite(8,1);
    digitalWrite(4,0);
    digitalWrite(9,1);

  }else if(sensor_alto <= 10){

    digitalWrite(7,0);
    digitalWrite(8,0);
    digitalWrite(4,0);
    digitalWrite(9,0);

  }


}

# data[].attributes.body
#include <MPU6050_tockn.h>
#include <Wire.h>

MPU6050 mpu6050(Wire);

void setup() {
  Serial.begin(9600);

  Wire.begin();
  mpu6050.begin();
  //mpu6050.calcGyroOffsets(true);
}

void loop() {

  mpu6050.update();

  int angulo = mpu6050.getAngleY();

  //Serial.print("angleX : ");
  //Serial.print(mpu6050.getAngleX());
  //Serial.print("\tangleY : ");
  //Serial.print(mpu6050.getAngleY());
  //Serial.print("\tangleZ : ");

  Serial.println(angulo);

}

# data[].attributes.attachment_link.title
Remote Control Car Robot Transformer - DIY from Cardboard

# data[].attributes.attachment_link.title
Como montar um pack de baterias de lítio da forma CORRETA! Bicicletas, patinetes e demais! | EP2

# data[].attributes.body
Servo motor MG995

capacidade de levantamento

4,8V = 850 gramas

6,0V = 900 gramas

# data[].attributes.attachment_link.title
Qual o torque dum servo motor na prática? Quanto peso levanta? Testamos os modelos SG90 MG90S MG995

# data[].attributes.attachment_link.title
Registro motorizado barato para Arduino!

# data[].attributes.attachment_link.title
Medusa snake dress part 4 #wearables #3dprinting #arduino #fashion #robotics

# data[].attributes.attachment_link.title
Phoenix dress progress #engineering #arduino #sewing #robotics

# data[].attributes.attachment_link.title
How to make Ferrari Rc/cardboard/Automatic scissor door/trunk

# data[].attributes.attachment_link.title
How to make transformer car robot from cardboard