Configuração Pino ESP32 a nivel de registro

Para configurar um pino do ESP32 como entrada a nível de registro, utilizamos os registradores de controle de GPIO. O ESP32 possui um conjunto de registradores que permitem definir a direção dos pinos.

Configurando um pino como entrada:

Usamos o registrador GPIO_ENABLE_REG para definir se um pino é saída ou entrada.

• Para configurar como saída, escrevemos 1 no bit correspondente ao pino.
• Para configurar como entrada, escrevemos 0 no bit correspondente ao pino.

#include "soc/gpio_reg.h"
#include "driver/gpio.h"

#define PINS_MASK ((1 << 25) | (1 << 26) | (1 << 27) | (1 << 33))  // Máscara dos pinos escolhidos

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

    // Configurar múltiplos pinos como entrada
    REG_WRITE(GPIO_ENABLE_REG, REG_READ(GPIO_ENABLE_REG) & ~PINS_MASK);

    // (Opcional) Ativar pull-up interno para todos os pinos selecionados
    REG_WRITE(GPIO_PIN25_REG, REG_READ(GPIO_PIN18_REG) | (1 << GPIO_PIN_PAD_DRIVER_S));
    REG_WRITE(GPIO_PIN26_REG, REG_READ(GPIO_PIN19_REG) | (1 << GPIO_PIN_PAD_DRIVER_S));
    REG_WRITE(GPIO_PIN27_REG, REG_READ(GPIO_PIN21_REG) | (1 << GPIO_PIN_PAD_DRIVER_S));
    REG_WRITE(GPIO_PIN33_REG, REG_READ(GPIO_PIN22_REG) | (1 << GPIO_PIN_PAD_DRIVER_S));
 
    // Alternativamente, pode usar a API oficial:
    // gpio_set_direction(GPIO_NUM_25, GPIO_MODE_INPUT);
    // gpio_set_direction(GPIO_NUM_26, GPIO_MODE_INPUT);
    // gpio_set_direction(GPIO_NUM_27, GPIO_MODE_INPUT);
    // gpio_set_direction(GPIO_NUM_33, GPIO_MODE_INPUT);
 }

void loop() {
    // Ler estado de todos os pinos simultaneamente
    uint32_t estado_pinos = REG_READ(GPIO_IN_REG) & PINS_MASK;

    // Imprimir estados individuais
    Serial.print("P25: "); Serial.print((estado_pinos >> 25) & 1);
    Serial.print(" | P26: "); Serial.print((estado_pinos >> 26) & 1);
    Serial.print(" | P27: "); Serial.print((estado_pinos >> 27) & 1);
    Serial.print(" | P33: "); Serial.print((estado_pinos >> 33) & 1);
   
    delay(500);
}

Observação

1. Desativar saída:

   • REG_READ(GPIO_ENABLE_REG) & ~(1 << PINO):
     • Lê o registrador GPIO_ENABLE_REG.
     • Usa & ~() para limpar o bit correspondente ao pino (definindo-o como entrada).
     • Grava de volta com REG_WRITE().

2. Ativar Pull-up (opcional):

   • GPIO_PINn_REG(PINO) controla características do pino, como pull-up/down.

3. Leitura do pino:

   • REG_READ(GPIO_IN_REG) >> PINO) & 1:
     • Lê o estado dos pinos de entrada.
     • Faz um deslocamento (>>) e máscara (& 1) para pegar apenas o bit do pino desejado.

Alternativamente, pode usar gpio_set_direction(PINO, GPIO_MODE_INPUT); da API ESP-IDF para facilitar.

Explicação

4. Criando uma máscara com os pinos desejados:

#define PINS_MASK ((1 << 25) | (1 << 26) | (1 << 27) | (1 << 33))

Define uma máscara de bits que representa os pinos 25, 26, 21, 27 e 33.

5. Configuramos todos os pinos como entrada ao mesmo tempo:

REG_WRITE(GPIO_ENABLE_REG, REG_READ(GPIO_ENABLE_REG) & ~PINS_MASK)

• Lê o registrador GPIO_ENABLE_REG (que define pinos como saída).
• Usa & ~PINS_MASK para limpar os bits dos pinos desejados, definindo-os como entrada.
• Escreve de volta no registrador com REG_WRITE().

6. Ativando o pull-up interno (opcional):

REG_WRITE(GPIO_PIN25_REG, REG_READ(GPIO_PIN25_REG) | (1 << GPIO_PIN_PAD_DRIVER_S));

• Isso pode ser feito para cada pino individualmente..
• Fazemos a leitura dos estados dos pinos de forma eficiente:

uint32_t estado_pinos = REG_READ(GPIO_IN_REG) & PINS_MASK

Lê todos os pinos de entrada de uma vez e aplica a máscara PINS_MASK para obter apenas os bits relevantes.​​​Exibição dos estados individuais dos pinos:

• Serial.print((estado_pinos >> 25) & 1);
  

• Para cada pino, deslocamos (>>) o valor lido para a posição certa e aplicamos & 1 para pegar o bit correto.

Vantagens dessa abordagem

Eficiência → Lê vários pinos ao mesmo tempo sem múltiplas chamadas de função.
Baixo nível → Usa registradores diretamente, sem sobrecarga de bibliotecas.
Mais rápido que a API ESP-IDF para leitura de múltiplos pinos ao mesmo tempo.