Estudo de Caso

Construa o código de um programa da plataforma Arduino que controla os movimentos de um robó. Este robo possui dois sensores infravermelhos, que fazem com que ele
siga uma trajetória desenhada no chão, e dois motores, um para cada roda de tração. Quando os sensores detectam a necessidade de acertar a rota, os motores devem ser
manipulados a fim de realizar o acerto. Por exemplo, se o robó estiver desviando a rota para a esquerda, o robo deve se mover para a direita até que a rota seja acertada. Para
isto, o motor da direita deve ser revertido (rodar para trás), e o da esquerda deve continuar ligado (rodando para frente). Quando a rota estiver certa, ambos os motores
devem ser ligados para frente, para que o robó continue andando em frente.

O robo possui um botão de acionamento que, enquanto pressionado, o robo deve seguir em movimento e, se solto, deve parar o movimento.

Os sensores funcionam da seguinte forma: os sensores são digitais e booleanos possuindo apenas valor 0 e valor 1, o valor 0 significa que o sensor não detectou desvio na
trajetória, e o valor 1 significa que o sensor detectou um desvia na trajetória.

Os movimentos possíveis são para a esquerda (reverter o motor da esquerda e manter o motor da direita a frente), para a direita (reverter o motor da direita e manter a motor
da esquerda a frente), para frente (manter os dois motores a frente), e para trás (reverter os dois motores).

Question

Estudo de Caso

Construa o código de um programa da plataforma Arduino que controla os movimentos de um robó. Este robo possui dois sensores infravermelhos, que fazem com que ele
siga uma trajetória desenhada no chão, e dois motores, um para cada roda de tração. Quando os sensores detectam a necessidade de acertar a rota, os motores devem ser
manipulados a fim de realizar o acerto. Por exemplo, se o robó estiver desviando a rota para a esquerda, o robo deve se mover para a direita até que a rota seja acertada. Para
isto, o motor da direita deve ser revertido (rodar para trás), e o da esquerda deve continuar ligado (rodando para frente). Quando a rota estiver certa, ambos os motores
devem ser ligados para frente, para que o robó continue andando em frente.

O robo possui um botão de acionamento que, enquanto pressionado, o robo deve seguir em movimento e, se solto, deve parar o movimento.

Os sensores funcionam da seguinte forma: os sensores são digitais e booleanos possuindo apenas valor 0 e valor 1, o valor 0 significa que o sensor não detectou desvio na
trajetória, e o valor 1 significa que o sensor detectou um desvia na trajetória.

Os movimentos possíveis são para a esquerda (reverter o motor da esquerda e manter o motor da direita a frente), para a direita (reverter o motor da direita e manter a motor
da esquerda a frente), para frente (manter os dois motores a frente), e para trás (reverter os dois motores).

Accepted Answer

Com certeza! Aqui está uma possível estrutura para o código do Arduino, baseada na descrição fornecida:

```cpp
// Definição dos pinos
const int sensorEsquerda = 2;  // Pino do sensor esquerdo
const int sensorDireita = 3;   // Pino do sensor direito
const int motorEsquerdoFrente = 4; // Pino para o motor esquerdo (frente)
const int motorEsquerdoTras = 5;  // Pino para o motor esquerdo (trás)
const int motorDireitoFrente = 6;  // Pino para o motor direito (frente)
const int motorDireitoTras = 7;   // Pino para o motor direito (trás)
const int botao = 8;             // Pino do botão de acionamento

// Variáveis globais
int estadoBotao = 0;          // Estado atual do botão

void setup() {
  // Configuração dos pinos como entrada ou saída
  pinMode(sensorEsquerda, INPUT);
  pinMode(sensorDireita, INPUT);
  pinMode(motorEsquerdoFrente, OUTPUT);
  pinMode(motorEsquerdoTras, OUTPUT);
  pinMode(motorDireitoFrente, OUTPUT);
  pinMode(motorDireitoTras, OUTPUT);
  pinMode(botao, INPUT_PULLUP); // Usando o resistor interno de pull-up
}

void loop() {
  // Leitura do estado do botão
  estadoBotao = digitalRead(botao);

// Se o botão estiver pressionado, o robô se move
  if (estadoBotao == LOW) { // LOW porque estamos usando INPUT_PULLUP
    seguirTrajetoria();
  } else {
    pararRobo();
  }
}

void seguirTrajetoria() {
  // Leitura dos sensores
  int valorEsquerda = digitalRead(sensorEsquerda);
  int valorDireita = digitalRead(sensorDireita);

// Lógica de movimento baseada nos sensores
  if (valorEsquerda == 1 && valorDireita == 0) {
    // Desvio para a esquerda: mover para a direita
    moverDireita();
  } else if (valorEsquerda == 0 && valorDireita == 1) {
    // Desvio para a direita: mover para a esquerda
    moverEsquerda();
  } else if (valorEsquerda == 0 && valorDireita == 0) {
    // Rota correta: seguir em frente
    moverFrente();
  } else {
    // Ambos os sensores detectaram desvio (situação incomum): parar
    pararRobo();
  }
}

void moverFrente() {
  digitalWrite(motorEsquerdoFrente, HIGH);
  digitalWrite(motorEsquerdoTras, LOW);
  digitalWrite(motorDireitoFrente, HIGH);
  digitalWrite(motorDireitoTras, LOW);
}

void moverEsquerda() {
  digitalWrite(motorEsquerdoFrente, LOW);
  digitalWrite(motorEsquerdoTras, HIGH);
  digitalWrite(motorDireitoFrente, HIGH);
  digitalWrite(motorDireitoTras, LOW);
}

void moverDireita() {
  digitalWrite(motorEsquerdoFrente, HIGH);
  digitalWrite(motorEsquerdoTras, LOW);
  digitalWrite(motorDireitoFrente, LOW);
  digitalWrite(motorDireitoTras, HIGH);
}

void pararRobo() {
  digitalWrite(motorEsquerdoFrente, LOW);
  digitalWrite(motorEsquerdoTras, LOW);
  digitalWrite(motorDireitoFrente, LOW);
  digitalWrite(motorDireitoTras, LOW);
}
```

**Explicação:**

1.  **Definição dos pinos:** Define os pinos que serão usados para os sensores, motores e botão.
2.  **Variáveis globais:** Define uma variável para armazenar o estado do botão.
3.  **`setup()`:** Configura os pinos como entrada ou saída. O pino do botão é configurado com `INPUT_PULLUP` para usar o resistor interno de pull-up do Arduino, simplificando a conexão do botão.
4.  **`loop()`:**
    *   Lê o estado do botão.
    *   Se o botão estiver pressionado (estado `LOW` devido ao `INPUT_PULLUP`), chama a função `seguirTrajetoria()`.
    *   Se o botão não estiver pressionado, chama a função `pararRobo()`.
5.  **`seguirTrajetoria()`:**
    *   Lê os valores dos sensores esquerdo e direito.
    *   Com base nos valores dos sensores, decide qual ação tomar:
        *   Se o sensor esquerdo detectar um desvio e o direito não, move para a direita.
        *   Se o sensor direito detectar um desvio e o esquerdo não, move para a esquerda.
        *   Se ambos os sensores não detectarem desvio, move para frente.
        *   Se ambos os sensores detectarem desvio, para o robô (situação incomum).
6.  **Funções de movimento (`moverFrente()`, `moverEsquerda()`, `moverDireita()`, `pararRobo()`):**
    *   Controlam os motores para realizar os movimentos desejados.
    *   Usam `digitalWrite()` para definir os pinos dos motores como `HIGH` ou `LOW`, controlando a direção de rotação.

**Observações:**

*   Este código é uma estrutura básica e pode precisar de ajustes dependendo do seu robô específico.
*   Você pode precisar ajustar os valores dos pinos e a lógica de movimento para corresponder ao seu hardware.
*   Considere adicionar delays para controlar a velocidade dos motores e evitar movimentos bruscos.
*   Este código assume que os sensores retornam 1 quando detectam um desvio e 0 quando não detectam. Se seus sensores funcionarem de forma diferente, você precisará ajustar a lógica de acordo.

Estudo de Caso Construa o código de um programa da platafor...

Ask a question and receive an answer instantly