Algoritmo da Mão Direita para Solução de Labirintos

O algoritmo da mão direita é uma técnica simples e eficaz utilizada para navegar e escapar de labirintos do tipo simples (ou seja, labirintos em que todas as paredes são interconectadas e não existem áreas isoladas). A ideia central é manter sempre a “mão direita” encostada em uma parede enquanto se avança pelo labirinto, garantindo que eventualmente se encontre a saída. Esse algoritmo é especialmente útil em robôs móveis com sensores de proximidade e motores independentes.

Como Funciona

Imagine caminhar por um labirinto com a mão encostada sempre à parede da direita. Se houver um caminho à direita, vire à direita. Caso contrário, se à frente for possível, siga em frente. Se à frente não for possível, vire à esquerda até encontrar uma direção livre. Essa técnica garante a saída de qualquer labirinto que seja simplesmente conexo (sem loops desconectados ou “ilhas”).

Aplicação no Controle de Robôs

Num robô com dois motores — um para a roda esquerda e outro para a direita — podemos implementar esse algoritmo controlando a direção com base nas leituras de sensores que detectam parede à direita, à frente e à esquerda. A função que aciona os motores será controle_motor(int8_t motor_esq, int8_t motor_dir), onde valores positivos movem o motor para frente e negativos para trás.

Exemplo:

controle_motor(100, 100); → anda para frente.
controle_motor(-100, 100); → gira para a esquerda.
controle_motor(100, -100); → gira para a direita.

Código em C (Simplificado)

Aqui está uma simulação básica do algoritmo, assumindo funções fictícias de leitura de sensores:

#include <stdint.h>
#include <stdbool.h>

// Protótipo da função de controle do motor
void controle_motor(int8_t motor_esq, int8_t motor_dir);

// Protótipos de sensores (implementação depende do hardware)
bool parede_direita();
bool parede_frente();
bool parede_esquerda();

// Ações básicas
void andar_frente() {
    controle_motor(100, 100);
}

void girar_direita() {
    controle_motor(100, -100);
}

void girar_esquerda() {
    controle_motor(-100, 100);
}

void parar() {
    controle_motor(0, 0);
}

// Loop principal
void resolver_labirinto() {
    while (true) {
        if (!parede_direita()) {
            // Gira para a direita e anda
            girar_direita();
        } else if (!parede_frente()) {
            andar_frente();
        } else {
            // Enquanto houver parede à frente, girar à esquerda
            while (parede_frente()) {
                girar_esquerda();
            }
        }
        // Pequeno atraso ou leitura de sensores para próxima decisão
    }
}

O algoritmo da mão direita não funciona em labirintos com “ilhas” ou passagens desconectadas.
É simples de implementar em microcontroladores e ideal para robôs iniciantes.
Pode ser complementado com sensores infravermelhos ou ultrassônicos para detecção de paredes.
É um bom ponto de partida para algoritmos mais avançados como DFS, BFS ou A*.