Esptop 10 com sensor de movimento PIR usando interrupções e temporizadores - Arduino IDE

O ESP32 é uma placa de microcontrolador baseada em IoT que pode ser usada para interagir, controlar e ler diferentes sensores. PIR ou Sensor de movimento é um dos dispositivos que podemos interagir com o ESP32 para detectar o movimento de um objeto na amplitude de sensor de movimento usando o ESP32.

Antes de começarmos a interface o ESP32 com o sensor pir, precisamos saber como as interrupções funcionam e como lê -las e lidar com eles no ESP32. Em seguida, devemos entender o conceito central de atraso () e Millis () função na programação ESP32.

Vamos discutir o funcionamento do PIR com o ESP32 em detalhes.

Aqui está o conteúdo deste artigo:

1. O que são interrupções
• 1.1: interrompe os pinos no ESP32
• 1.2: Como chamar uma interrupção no ESP32
2. Timers na programação ESP32
• 2.1: Função de atraso ()
• 2.2: Função Millis ()
3. Interface PIR Sensor com ESP32
   • 3.1: Sensor de movimento PIR (HC-SR501)
   • 3.2: pinout hc-sr501
   • 3.3: código
   • 3.4: saída

1: O que são interrupções

A maioria dos eventos que acontecem na programação ESP32 é executada sequencialmente, o que significa linha por linha de execução do código. Para lidar e controlar os eventos que não precisam ser executados durante a execução seqüencial do código e Interrompe são usados.

Por exemplo, se queremos executar uma determinada tarefa quando ocorrer qualquer evento especial, ou um sinal de gatilho é dado aos pinos digitais do microcontrolador, usamos interrupções.

Com a interrupção, não precisamos verificar continuamente o estado digital do pino de entrada ESP32. Quando uma interrupção ocorre, o processador interrompe o programa principal e uma nova função é chamada, que é conhecida como ISR (Rotina de serviço de interrupção). Esse Isr A função lida com a interrupção causada após esse retorno ao programa principal e comece a executá -la. Um dos exemplos de ISR é Sensor de movimento PIR qual gera uma interrupção quando o movimento é detectado.

1: interrompe os pinos no ESP32

Uma interrupção externa ou de hardware pode ser causada por qualquer módulo de hardware, como sensor de toque ou botão. Interrupções de toque acontecem quando um toque é detectado em pinos ESP32 ou interrupção do GPIO também pode ser usada quando uma tecla ou botão é pressionada.

Neste artigo, desencadearemos uma interrupção quando a moção for detectada usando o sensor PIR com ESP32.

Quase todos os pinos do GPIO, exceto 6 pinos integrados SPI que geralmente vêm no 36-A versão PIN da placa ESP32 não pode ser usada para fins de chamada de interrupção. Portanto, para receber a interrupção externa a seguir, os pinos destacados na cor roxa que se pode usar no ESP32:

Esta imagem é de 30 pinos ESP32.

2: chamando uma interrupção no ESP32

Para usar a interrupção no ESP32, podemos ligar Anex AnexInterrupt () função.

Esta função aceita a seguir três argumentos:

• • GPIO PIN
  • Função a ser executada
  • Modo

AnexeRrupt (DigitalPINToiTrupt (GPIO), função, modo);

1: GPIO PIN é o primeiro argumento chamado dentro do Anex AnexInterrupt () função. Por exemplo, para usar o pino digital 12 como uma fonte de interrupção, podemos chamá -la usando DigitalPintoiToiTrupt (12) função.

2: função a ser executado é o programa executado toda vez que a interrupção é alcançada ou desencadeada por uma fonte externa ou interna. Pode estar piscando um LED ou girando um alarme de incêndio.

3: modo é o terceiro e último argumento que a função de interrupção precisa. Descreve quando acionar a interrupção. A seguir, os modos podem ser usados:

• • Baixo: Acionar a interrupção toda vez que o pino GPIO definido é baixo.
  • Alto: Acionar a interrupção toda vez que o pino GPIO definido é alto.
  • Mudar: A interrupção do gatilho sempre que o GPIO PIN altera seu valor de alto para baixo ou vice -versa.
  • Caindo: É o modo de acionar uma interrupção quando um certo pino começa a cair de alto estado para baixo.
  • Ascendente: É o modo de acionar uma interrupção quando um certo pino começa a subir de baixo estado para alto.

Hoje estaremos usando Ascendente Modo como um terceiro argumento para a função de interrupção sempre que o sensor pir detectar o LED ou o sensor de interrupção, porque vai de baixo estado para alto.

2: Timers na programação ESP32

Os temporizadores na programação do microcontrolador desempenham um papel significativo na execução de instruções para um período específico do timer ou em uma instância específica do tempo.

Duas funções principais comumente usadas para acionar a saída são atraso() e milis (). A diferença entre os dois como a função de atraso () interrompe o restante do programa quando começar a executar enquanto o Millis () é executado pelo período definido, então o programa remonta às funções principais.

Aqui estaremos usando um LED com sensor pir e não queremos brilhar continuamente após um gatilho de interrupção. Usaremos a função Millis () que nos permite brilhar por algum tempo definido e depois remonta ao programa original uma vez que o carimbo de hora passa.

1: Função de atraso ()

a função de atraso () é bem simples, é preciso apenas um argumento que é EM do tipo de dados longo não assinado. Este argumento representa o tempo em milissegundos, queremos pausar o programa até que ele se mova para a próxima linha.

Por exemplo, a seguinte função interromperá o programa para 1 segundo.

Atraso (1000)

Atraso () é um tipo de função de bloqueio para programação de microcontroladores. touch () bloqueia o restante do código a ser executado até que esse tempo de função específico não seja concluído. Se quisermos executar várias instruções, devemos evitar o uso de funções de atraso, em vez disso, podemos usar módulos Millis ou Timer Externo.

2: Função Millis ()

A função Millis () retorna o número de milissegundos aprovados desde que a placa ESP32 começou a executar o programa atual. Ao escrever algumas linhas de código, podemos calcular facilmente o tempo presente em qualquer caso enquanto executa o código ESP32.

Millis é amplamente utilizado onde precisamos executar várias tarefas sem bloquear o restante do código. Aqui está a sintaxe da função Millis usada para calcular quanto tempo passou para que possamos executar uma instrução específica.

if (currentMillis - anteriormillis> = intervalo)
anteriormillis = currentMillis;

Este código subtrai o millis anterior () do Current Millis () se o tempo subtraído for igual a definir o intervalo que uma instrução específica será executada. Digamos que queremos piscar um LED por 10 segundos. Após a cada 5 minutos, podemos definir o intervalo de tempo igual a 5 minutos (300000ms). O código verificará o intervalo toda vez que o código é executado, uma vez que atingir ele piscará o LED por 10 segundos.

Observação: Aqui estaremos usando a função Millis () para interface Esp32 com o sensor PIR. A principal razão por trás do uso de mili e não atraso é que a função Millis () não bloqueia o código como a função de atraso (). Então, uma vez que o PIR detectar movimento, uma interrupção será gerada. O uso da função de interrupção millis () acionará o LED para o tempo definido após isso se o movimento for interrompido, a função () será redefinida e aguardará a próxima interrupção.

No caso de usarmos a função de atraso (), ele bloqueará completamente o código e qualquer interrupção causada não será lida pelo ESP32, resultando em falha do projeto.

3: Interface PIR Sensor com ESP32

Aqui estaremos usando a função Millis () no Código de IDE Arduino, porque queremos acionar LED toda vez que o sensor PIR detecta algum movimento. Este LED brilhará por um tempo definido depois disso, voltará à condição normal.

Aqui está uma lista de componentes que seremos necessários:

• • Conselho de Desenvolvimento Esp32
  • Sensor de movimento PIR (HC-SR501)
  • LIDERADO
  • Resistor de 330 ohm
  • Conectando fios
  • Pão de pão

Esquemático Para o sensor PIR com ESP32:

As conexões PIN do ESP32 com o sensor PIR é:

1: Sensor de movimento PIR (HC-SR501)

PIR é um acrônimo para Sensor de infravermelho passivo. Ele usa um par de sensores piroelétricos que detectam calor ao redor do ambiente. Ambos os sensores piroelétricos estão um após o outro e quando um objeto entra em seu alcance, uma mudança na energia térmica ou a diferença de sinal entre esses dois sensores faz com que a saída do sensor PIR seja baixa. Depois que o pino pir out for baixo, podemos definir uma instrução específica para executar.

A seguir, as características do sensor PIR:

• • A sensibilidade pode ser definida, dependendo da localização do projeto (como sensor mouse ou movimento de folhas).
  • O sensor pir pode ser definido por quanto tempo detecta um objeto.
  • Amplamente utilizado em alarmes de segurança doméstica e outras aplicações de detecção de movimento baseadas em térmicas.

2: pinout hc-sr501

Pir hc-sr501 vem com três pinos. Dois deles são pinos de potência para VCC e GND e um é o pino de saída para o sinal de gatilho.

A seguir, a descrição dos pinos do sensor pir:

3: código

Agora, para programar ESP32, escreva o código fornecido no Arduino IDE Editor e envie -o para o ESP32.

#Define timeSonds 10
const int led = 4; /*GPIO PIN 4 definido para LED*/
const int pir_out = 13; /*GPIO pino 13 para pir out*/
Long current_time realmente assinado = millis (); /*variável definida para armazenar valores de milis*/
não assinado long anterior_trig = 0;
boolean starting_time = false;
void irram_attr detectsMoVement () /*Verifique se há movimento* /
Serial.println ("movimento detectado");
DigitalWrite (LED, alto); /*Ligue o LED se a condição for verdadeira*/
Starting_time = true;
Anterior_trig = millis ();

Void Setup ()
Serial.começar (115200); /*Taxa de transmissão para comunicação serial*/
pinmode (pir_out, input_pullup); /*Modo de sensor de movimento pir definido*/
/*PIR está configurado no modo de ascensão, defina o pino do sensor de movimento como saída*/
Anex AnextInterrupt (DigitalPINToiTrupt (PIR_OUT), detectSmoVement, Rising);
pinmode (LED, saída); /*O conjunto levou a baixo*/
DigitalWrite (LED, Low);

Void Loop ()
Current_time = millis (); /*Armazene horário atual*/
if (starting_time && (current_time - anterior_trig> (timeconds*1000))) /*intervalo de tempo após o qual o LED desligará* /
Serial.println ("movimento parado"); /*Imprime o movimento parado se nenhum movimento detectado*/
DigitalWrite (LED, Low); /*Definido levou a baixa se a condição for falsa*/
Starting_time = false;

O código começou definindo pinos GPIO para saída de LED e PIR. Em seguida, criamos três variáveis ​​diferentes que ajudarão a ligar o LED quando o movimento for detectado.

Essas três variáveis ​​são Current_time, anterior_trig, e Starting_time. Essas variáveis ​​armazenarão o horário atual, o tempo em que a moção é detectada e o temporizador após a detecção de movimento.

Na parte de configuração primeiro, definimos a taxa de transmissão em série para comunicação. Próximo usando pinmode () Defina o sensor de movimento PIR como pullup de entrada. Para definir a interrupção do PIR Anex AnexInterrupt () é descrito. O GPIO 13 é descrito para detectar movimento no modo de ascensão.

Em seguida, em Loop () parte do código, usando a função Millis (), ligamos e desligamos o LED quando um gatilho é alcançado.

4: saída

Na seção de saída, podemos ver que o objeto está fora do alcance do sensor pir, de modo que o LIDERADO Está virado DESLIGADO.

Agora a moção detectada pelo LED do sensor PIR virará SOBRE para 10 Sec depois disso, se nenhum movimento for detectado, ele permanecerá DESLIGADO Até o próximo gatilho ser recebido.

A saída seguinte é mostrada pelo monitor serial em Arduino IDE.

Conclusão

Um sensor PIR com ESP32 pode ajudar a detectar o movimento de objetos que passam por sua faixa. Usando a função de interrupção na programação ESP32, podemos acionar uma resposta em algum pino GPIO específico. Quando a alteração for detectada, a função de interrupção será acionada e um LED ligará.