ESPTOP 10 avec capteur de mouvement PIR en utilisant des interruptions et des minuteries - Arduino IDE

ESP32 est une carte de microcontrôleur basée sur l'IoT qui peut être utilisée pour interfacer, contrôler et lire différents capteurs. PIR ou le capteur de mouvement est l'un des appareils que nous pouvons interfacer avec ESP32 pour détecter le mouvement d'un objet dans le capteur de plage de mouvement en utilisant ESP32.

Avant de commencer à interfacer ESP32 avec le capteur PIR, nous devons savoir comment les interruptions fonctionnent et comment les lire et les gérer dans ESP32. Ensuite, nous devons comprendre le concept de base de la fonction delage () et de Millis () dans la programmation ESP32.

Discutons du travail de PIR avec ESP32 en détail.

Voici le contenu de cet article:

1. Que sont les interruptions
• 1.1: interrompt les broches dans ESP32
• 1.2: Comment appeler une interruption dans ESP32
2. Minuteries dans la programmation ESP32
• 2.1: fonction de retard ()
• 2.2: Fonction Millis ()
3. Interfaçage du capteur PIR avec ESP32
   • 3.1: capteur de mouvement PIR (HC-SR501)
   • 3.2: Pinout HC-SR501
   • 3.3: code
   • 3.4: sortie

1: Quelles sont les interruptions

La plupart des événements qui se produisent dans la programmation ESP32 s'exécutent séquentiellement, ce qui signifie une exécution ligne par ligne du code. Pour gérer et contrôler les événements qui n'ont pas besoin d'exécuter pendant l'exécution séquentielle du code Interruptions sont utilisés.

Par exemple, si nous voulons exécuter une certaine tâche lorsqu'un événement spécial se produit, ou un signal de déclenchement est donné aux épingles numériques du microcontrôleur, nous utilisons l'interruption.

Avec l'interruption, nous n'avons pas besoin de vérifier en continu l'état numérique de la broche d'entrée ESP32. Lorsqu'une interruption se produit, le processeur arrête le programme principal et une nouvelle fonction est appelée ISR (Routine de service d'interruption). Ce ISR La fonction gère l'interruption causée après ce retour au programme principal et commencez à l'exécuter. L'un des exemples d'ISR est Capteur de mouvement PIR qui génère une interruption une fois le mouvement détecté.

1: interrompt les broches dans ESP32

Une interruption externe ou matérielle peut être causée par n'importe quel module matériel tel que le capteur tactile ou le bouton-poussoir. Les interruptions de toucher se produisent lorsqu'un toucher est détecté sur ESP32 PINS ou que l'interruption GPIO peut également être utilisée lorsqu'une touche ou un bouton-poussoir est appuyé.

Dans cet article, nous déclencherons une interruption lorsque le mouvement est détecté en utilisant le capteur PIR avec ESP32.

Presque toutes les broches GPIO sauf 6 broches intégrées SPI qui viennent généralement dans le 36-La version PIN de la carte ESP32 ne peut pas être utilisée à des fins d'interruption d'appel. Ainsi, pour recevoir l'interruption externe qui suit se trouvent les broches mises en évidence en couleur violette que l'on peut utiliser dans ESP32:

Cette image est d'une ESP32 à 30 broches.

2: appeler une interruption dans ESP32

Pour utiliser l'interruption dans ESP32, nous pouvons appeler fixerterrupt () fonction.

Cette fonction accepte les trois arguments:

• • Broche
  • Fonction à exécuter
  • Mode

attachinterrupt (DigitalPintoInterrup (GPIO), fonction, mode);

1: GPIO La broche est le premier argument appelé à l'intérieur du fixerterrupt () fonction. Par exemple, pour utiliser la broche numérique 12 comme source d'interruption, nous pouvons l'appeler en utilisant DigitalPintOinterrup (12) fonction.

2: fonction être exécuté est le programme exécuté à chaque fois une fois l'interruption atteinte ou déclenchée par une source externe ou interne. Il peut être soit clignotant une LED ou tournant une alarme incendie.

3: mode est le troisième et dernier argument dont la fonction d'interruption a besoin. Il décrit quand déclencher l'interruption. Voici les modes peuvent être utilisés:

• • Faible: Déclencher l'interruption à chaque fois que la broche GPIO définie est faible.
  • Haut: Déclencher l'interruption chaque fois que la broche GPIO définie est élevée.
  • Changement: Interruption de déclenchement chaque fois que la broche GPIO change sa valeur de haut à faible ou vice versa.
  • Chute: C'est le mode pour déclencher une interruption lorsqu'une certaine broche commence à tomber de haut.
  • En hausse: C'est le mode pour déclencher une interruption lorsqu'une certaine broche commence à passer de l'état bas à haut.

Aujourd'hui, nous utiliserons En hausse Mode comme troisième argument pour la fonction d'interruption chaque fois que le capteur PIR détecte la LED ou le capteur d'interruption s'allumer car il passe de l'état bas à haut.

2: minuteries dans la programmation ESP32

Les minuteries dans la programmation de microcontrôleur jouent un rôle important pour exécuter des instructions pour une période de minuterie spécifique ou à une instance spécifique de temps.

Deux fonctions principales couramment utilisées pour déclencher la sortie sont retard() et millis (). La différence entre les deux en tant que fonction de retard () arrête le reste du programme une fois qu'il commence à s'exécuter tandis que Millis () s'exécute pour la période définie, puis le programme revient aux fonctions principales.

Ici, nous utiliserons une LED avec capteur PIR et nous ne voulons pas le briller en continu après une interruption des déclencheurs. Nous utiliserons une fonction Millis () qui nous permet de le briller pendant un temps défini et redevient à nouveau au programme d'origine une fois que cette horodatage passe.

1: fonction de retard ()

La fonction de retard () est assez simple, il ne faut qu'un seul argument qui est SP de type de données longs non signé. Cet argument représente le temps en millisecondes que nous voulons suspendre le programme jusqu'à ce qu'il passe à la ligne suivante.

Par exemple, la fonction suivante arrêtera le programme pour 1 seconde.

retard (1000)

Delay () est une sorte de fonction de blocage pour la programmation des microcontrôleurs. Delay () bloque le reste du code à exécuter jusqu'à ce que ces heures de fonction particulières ne se terminent pas. Si nous voulons exécuter plusieurs instructions, nous devons éviter d'utiliser des fonctions de retard à la place, nous pouvons utiliser des modules Millis ou Timer RTC.

2: Fonction Millis ()

La fonction Millis () renvoie le nombre de millisecondes passées depuis que la carte ESP32 a commencé à exécuter le programme actuel. En écrivant quelques lignes de code, nous pouvons facilement calculer le temps présent en tout cas lors de l'exécution du code ESP32.

Millis est largement utilisé lorsque nous devons exécuter plusieurs tâches sans bloquer le reste du code. Voici la syntaxe de la fonction Millis utilisée pour calculer le temps passé pour que nous puissions exécuter une instruction spécifique.

if (currentMillis - précédemment Millis> = interval)
PREBERMILLIS = CurrentMillis;

Ce code soustait le millis précédent () de Millis actuel () si le temps soustrait équivaut à définir l'intervalle, une instruction spécifique sera exécutée. Disons que nous voulons clignoter une LED pendant 10 secondes. Après toutes les 5 minutes, nous pouvons régler l'intervalle de temps égal à 5 ​​minutes (300000 ms). Le code vérifiera l'intervalle chaque fois que le code s'exécute, une fois qu'il atteindra, il clignote la LED pendant 10 sec.

Note: Ici, nous utiliserons la fonction Millis () pour l'interfaçage ESP32 avec le capteur PIR. La principale raison derrière l'utilisation de Milli et non de délai est que la fonction Millis () ne bloque pas le code comme la fonction de retard (). Ainsi, une fois que le PIR détectera le mouvement, une interruption sera générée. L'utilisation de la fonction interruption millis () déclenchera la LED pendant la durée définie après cela si le mouvement est arrêté la fonction Millis () réinitialise et attendra l'interruption suivante.

Dans le cas où nous utilisons la fonction delt (), il bloquera complètement le code et toute interruption causée ne sera pas lue par ESP32 entraînant une défaillance du projet.

3: Interfaçage du capteur PIR avec ESP32

Ici, nous utiliserons la fonction Millis () dans le code IDE Arduino parce que nous voulons déclencher la LED chaque fois que le capteur PIR détecte un certain mouvement. Cette LED brillera pour une heure définie après cela reviendra à un état normal.

Voici une liste de composants dont nous serons requis:

• • Conseil de développement ESP32
  • Capteur de mouvement PIR (HC-SR501)
  • DIRIGÉ
  • Résistance de 330 ohms
  • Fils de connexion
  • Planche à pain

Schématique pour le capteur PIR avec ESP32:

Les connexions à broches de ESP32 avec le capteur PIR sont:

1: capteur de mouvement PIR (HC-SR501)

PIR est un acronyme pour capteur infrarouge passif. Il utilise une paire de capteurs pyroélectriques qui détectent la chaleur autour de son environnement. Ces deux capteurs pyroélectriques se trouvent l'un après l'autre et lorsqu'un objet entre dans sa plage, un changement d'énergie thermique ou la différence de signal entre ces deux capteurs fait que la sortie du capteur PIR est faible. Une fois que la broche PIR est basse, nous pouvons définir une instruction spécifique pour exécuter.

Voici les caractéristiques du capteur PIR:

• • La sensibilité peut être définie en fonction de l'emplacement du projet (comme la détection de la souris ou du mouvement des feuilles).
  • Le capteur PIR peut être défini pour la durée de la durée d'un objet.
  • Largement utilisé dans les alarmes de sécurité à domicile et autres applications de détection de mouvement thermique.

2: Pinout HC-SR501

PIR HC-SR501 est livré avec trois broches. Deux d'entre eux sont des broches d'alimentation pour VCC et GND et une est la broche de sortie pour le signal de déclenchement.

Voici la description des épingles de capteur PIR:

3: code

Maintenant, pour programmer ESP32, écrivez le code donné dans Arduino IDE Editor et téléchargez-le sur ESP32.

#Define Timeseconds 10
const int int = 4; / * GPIO broche 4 définie pour LED * /
const int pir_out = 13; / * GPIO PIN 13 pour PIR OUT * /
unsigned long current_time = Millis (); / * variable définie pour stocker les valeurs de millis * /
unsigned long préalable_trig = 0;
boolean start_time = false;
void iram_attr détectsmovement () / * Vérifiez le mouvement * /
En série.println ("Motion détecté");
DigitalWrite (LED, High); / * Allumez la LED si la condition est vraie * /
Start_time = true;
Précéaire_trig = millis ();

void setup()
En série.commencer (115200); / * Taux en bauds pour la communication série * /
pinMode (pir_out, input_pullup); / * Mode de capteur de mouvement pir défini * /
/ * Pir est configuré en mode montant, définissez la broche du capteur de mouvement comme sortie * /
attachinterrupt (DigitalPintOinterrupt (PIR_OUT), détectes lemovament, Rising);
PinMode (LED, sortie); / * régler LED à Low * /
DigitalWrite (LED, bas);

VOID LOOP ()
Current_time = Millis (); / * stocker l'heure actuelle * /
if (start_time && (current_time - préalable_trig> (TimesEconds * 1000))) / * L'intervalle de temps après quoi la LED s'éteindra * /
En série.println ("Motion arrêté"); / * Imprime le mouvement arrêté si aucun mouvement ne détecte * /
DigitalWrite (LED, bas); / * Définir la LED à la condition faible si la condition est fausse * /
Start_time = false;

Le code a commencé par définir des broches GPIO pour la sortie LED et PIR. Ensuite, nous avons créé trois variables différentes qui aideront à activer la LED lorsque le mouvement est détecté.

Ces trois variables sont Current_time, précédent_trig, et Heure de départ. Ces variables stockeront l'heure actuelle, l'heure à laquelle le mouvement est détecté et la minuterie après la détection du mouvement.

Dans la partie de configuration en premier, nous avons défini le taux de bauds en série pour la communication. Ensuite en utilisant pinMode () Réglez le capteur de mouvement PIR comme traction d'entrée. Pour définir l'interruption PIR fixerterrupt () est décrit. GPIO 13 est décrit pour détecter le mouvement sur le mode montant.

Suivant dans Loop () partie du code, en utilisant la fonction Millis (), nous avons activé et désactivé la LED lorsqu'un déclencheur est atteint.

4: sortie

Dans la section de sortie, nous pouvons voir que l'objet est hors de portée du capteur PIR, donc le DIRIGÉ est tourné DÉSACTIVÉ.

Maintenant, le mouvement détecté par la LED du capteur PIR tournera SUR pour dix seconde Après cela, si aucune motion n'est détectée, il restera DÉSACTIVÉ Jusqu'à ce que le déclencheur suivant soit reçu.

La sortie suivante est indiquée par le moniteur série dans Arduino IDE.

Conclusion

Un capteur PIR avec ESP32 peut aider à détecter le mouvement des objets passant par sa gamme. En utilisant la fonction d'interruption dans la programmation ESP32, nous pouvons déclencher une réponse à une broche GPIO spécifique. Lorsque la modification est détectée, la fonction d'interruption sera déclenchée et une LED s'allumera.