# TL:DR
>[!TLDR] Resumo
>Use `machine.Pin` e `machine.ExtInt` para lidar com interrupções no [[ESP32]] com [[MicroPython]]. Defina uma função de manipulador de interrupção, configure o pino como entrada, crie um objeto `ExtInt` que vincule o pino, o manipulador e o modo de disparo (por exemplo, `ExtInt.IRQ_FALLING`), e opcionalmente habilite/desabilite ou troque os manipuladores. Lembre-se de fazer a debouncing e mantenha os manipuladores de interrupção curtos.
# Informações
Usar sinais de interrupção no [[ESP32]] com [[MicroPython]] envolve o uso das classes `Pin` e `ExtInt` do módulo `machine`. Aqui está um detalhamento de como fazer isso:
**1. Importando Módulos Necessários:**
```python
from machine import Pin, ExtInt
```
**2. Definindo a Função do Manipulador de Interrupção:**
Esta função será executada quando a interrupção for acionada. Ela recebe o objeto do pino como argumento.
```python
def interrupt_handler(pin):
print("Interrupção acionada no pino:", pin)
# Adicione sua lógica de tratamento de interrupção aqui
# ...
```
**3. Configurando o Pino como Entrada com Pull-up/Pull-down:**
Você precisa configurar o pino que acionará a interrupção. Especifique o número do pino, defina-o como entrada (`Pin.IN`) e, opcionalmente, habilite um resistor de pull-up ou pull-down.
```python
interrupt_pin = Pin(14, Pin.IN, Pin.PULL_UP) # Exemplo: Pino 14 com pull-up
```
**4. Criando o Objeto `ExtInt`:**
Este objeto vincula o pino ao manipulador de interrupção e especifica o modo de disparo.
```python
interrupt = ExtInt(interrupt_pin, ExtInt.IRQ_FALLING, Pin.PULL_UP, interrupt_handler)
```
* **`interrupt_pin`:** O objeto `Pin` que você configurou.
* **`ExtInt.IRQ_FALLING`:** O modo de disparo. As opções comuns incluem:
* `ExtInt.IRQ_RISING`: Acionado em uma borda de subida (baixo para alto).
* `ExtInt.IRQ_FALLING`: Acionado em uma borda de descida (alto para baixo).
* `ExtInt.IRQ_RISING_FALLING`: Acionado em ambas as bordas de subida e descida.
* **`Pin.PULL_UP`:** Isso deve corresponder à configuração de pull-up/pull-down que você usou ao configurar o pino. Use `Pin.PULL_DOWN` se você usou um resistor de pull-down. Se nenhum pull-up/pull-down for usado, omita este argumento ou defina-o como `None`.
* **`interrupt_handler`:** A função a ser chamada quando a interrupção ocorrer.
**5. (Opcional) Desabilitando a Interrupção:**
Você pode desabilitar temporariamente a interrupção:
```python
interrupt.disable()
```
**6. (Opcional) Reabilitando a Interrupção:**
```python
interrupt.enable()
```
**7. (Opcional) Trocando Manipuladores de Interrupção:**
Se você precisar mudar a função que manipula a interrupção:
```python
def new_interrupt_handler(pin):
print("Novo manipulador de interrupção acionado!")
interrupt.irq(handler=new_interrupt_handler, trigger=ExtInt.IRQ_FALLING) # O disparo também pode ser alterado
```
**Exemplo Completo (Interrupção na Borda de Descida com Pull-up):**
```python
from machine import Pin, ExtInt
def interrupt_handler(pin):
print("Botão pressionado!")
interrupt_pin = Pin(14, Pin.IN, Pin.PULL_UP)
interrupt = ExtInt(interrupt_pin, ExtInt.IRQ_FALLING, Pin.PULL_UP, interrupt_handler)
# Seu loop principal do programa pode rodar aqui...
while True:
pass # Seu código vai aqui
```
**Considerações Chave:**
* **Debouncing:** Botões físicos podem "quicar", causando múltiplas interrupções em um único pressionamento. Você provavelmente precisará implementar debouncing em seu `interrupt_handler` para evitar isso. Um debouncing de software simples envolve um pequeno atraso e a verificação do estado do pino novamente.
* **Contexto de Interrupção:** O manipulador de interrupção é executado em um contexto de interrupção, o que significa que ele não deve realizar operações de longa duração ou usar funções que não sejam seguras para interrupções. Mantenha o manipulador curto e focado em tarefas essenciais.
* **Escolha do Pino:** Nem todos os pinos do [[ESP32]] suportam interrupções. Consulte a documentação do [[ESP32]] para uma lista de pinos capazes de interrupção.
* **Disparo por Borda vs. Disparo por Nível:** A classe `ExtInt` suporta principalmente o disparo por borda. Se você precisar de interrupções disparadas por nível, pode ser necessário explorar abordagens alternativas ou usar um temporizador para sondar periodicamente o estado do pino.
Esta explicação abrangente deve ajudá-lo a usar efetivamente os sinais de interrupção em seu [[ESP32]] com [[MicroPython]]. Lembre-se de adaptar o código e os números dos pinos à sua configuração de hardware específica. Se você tiver uma aplicação particular em mente, fornecer mais detalhes permitirá um exemplo mais personalizado.