Robocup 2025 by Pedro Lucas

pl1997433 — 2024-12-18 23:14:15 UTC

pl1997433 — 2024-12-18 23:42:27 UTC

pl1997433 — 2024-12-18 23:55:08 UTC

Servo motor MG995

capacidade de levantamento

4,8V = 850 gramas
6,0V = 900 gramas

Boas práticas para uso de Servo Motor

pl1997433 — 2024-12-19 00:07:12 UTC

pl1997433 — 2024-12-19 00:30:33 UTC

pl1997433 — 2024-12-19 00:31:23 UTC

pl1997433 — 2024-12-19 23:06:06 UTC

pl1997433 — 2024-12-19 23:27:58 UTC

Dimensões

pl1997433 — 2024-12-19 23:55:26 UTC

pl1997433 — 2024-12-19 23:55:39 UTC

pl1997433 — 2024-12-19 23:56:42 UTC

pl1997433 — 2025-01-03 00:56:14 UTC

pl1997433 — 2025-01-13 19:52:27 UTC

Monster motor shield + arduino mega

pl1997433 — 2025-02-11 22:05:29 UTC

#include  // 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);

  }


}

Código sensor giroscópio

pl1997433 — 2025-02-13 00:29:18 UTC


#include 
#include 

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);

}

Código - Inclinação Corpo

pl1997433 — 2025-02-18 01:48:57 UTC

/*
  Componentes usados:
  - Arduino Mega
  - 2 sensores ultrassônicos
  - 1 Monster Motor Shield
*/

#include  // 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);
}

Código movimentação da base

pl1997433 — 2025-02-25 22:19:16 UTC

/*
  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);
   
}

Arduino TX - Transmissor

pl1997433 — 2025-02-28 17:21:58 UTC

//B1T A B1T
//www.youtube.com.br/bitabit

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

#include 

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);
}

Arduino RX - Receptor

pl1997433 — 2025-02-28 17:22:29 UTC

//B1T A B1T
//www.youtube.com.br/bitabit

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

#include 

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]);
  }
}

Código Atualizado Trior - Erguer Corpo Trio

2025-04-25 15:50:13 UTC

/*
  Componentes usados:
  - Arduino Mega
  - 2 sensores de campo magnético
  - 1 Monster Motor Shield
*/

#include  // 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);
}

Codigo atualizado movimentacao base

2025-05-13 16:00:58 UTC

/*
  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);
   
}

base trio

2025-05-14 15:07:43 UTC

/*
  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);
   
}

erguer corpo

2025-05-14 15:08:10 UTC

/*
  Componentes usados:
  - Arduino Mega
  - 2 sensores de campo magnético
  - 1 Monster Motor Shield
*/

#include  // 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);
}

erguer corpo

2025-05-21 15:39:18 UTC

/*
  Componentes usados:
  - Arduino Mega
  - 2 sensores de campo magnético
  - 1 Monster Motor Shield
  - Código Erguer Corpo
*/

#include 
#include  // 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);
}

código base trio

2025-05-21 15:40:03 UTC

Componentes usados:

- Arduino Mega

- 1 Monster Motor Shield

- Código Base Trio

#include

#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);

}

2025-05-21 16:14:37 UTC

usar essa estrutura para fazer o braco

pl1997433 — 2025-05-24 22:45:18 UTC

pl1997433 — 2025-05-24 22:58:16 UTC

pl1997433 — 2025-05-25 00:08:59 UTC

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

Base Trio

2025-07-08 20:22:41 UTC

/*
    Componentes usados:
    - Arduino Mega
    - 1 Monster Motor Shield
    - 1 MPU6050 (giroscopio)
    - Código Base Trio
  */

  #include 
  #include   // biblioteca do giroscopio
  #include 
  #include   

  //***********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);
   
}

Código Erguer Corpo

2025-07-08 20:25:18 UTC

/*
  Componentes usados:
  - Arduino Mega
  - 2 sensores de campo magnético
  - 1 Monster Motor Shield
  - Código Erguer Corpo
*/

#include 

#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);
    }
  }
*/
}

base trio

2025-07-10 21:05:05 UTC

/*
    Componentes usados:
    - Arduino Mega
    - 1 Monster Motor Shield
    - 1 MPU6050 (giroscopio)
    - Código Base Trio
  */

  #include 
  #include   // biblioteca do giroscopio
  #include 
  #include   

  //***********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);
   
}

erguer corpo

2025-07-12 20:06:37 UTC

  /*
    Componentes usados:
    - Arduino Mega
    - 2 sensores de campo magnético
    - 1 Monster Motor Shield
    - Código Erguer Corpo
  */

  #include 

  #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);
    }
  }
}

base trio

2025-07-12 20:08:43 UTC

/*
    Componentes usados:
    - Arduino Mega
    - 1 Monster Motor Shield
    - 1 MPU6050 (giroscopio)
    - Código Base Trio
  */

  #include 
  #include   // biblioteca do giroscopio
  #include 
  #include   

  //***********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);
  }
// -------------------------------------------------------------------------------

pl1997433 — 2025-07-14 11:02:26 UTC

pl1997433 — 2025-07-14 11:02:54 UTC