Sensore infrarosso passivo
PIR HC-SR501
USO con Arduino

Ultimo aggiornamento 17 marzo 2019


JLCPCB - 2$ per prototipi di PCB, di qualsiasi colore. Produzione in 24 ore!
L'Azienda di prototipi PCB più popolare, con oltre 700.000 clienti in tutto il mondo!
Recati presso la JLCPCB, riceverai regali e coupon gratuiti
presso Maker Faire Rome il 18-20 ottobre


Indice

Descrizione

Il sensore utilizzato in questi esempi è il sensore PIR tipo HC-SR501 si presenta come una scheda dalle seguenti dimensioni 33x25mm e di 8g di peso. Questo modulo è un sensore a infrarossi in grado di fornire un segnale alto a 3V quando rileva un corpo caldo in movimento.

OurPCB, your most reliable PCB and PCBA supplier.

Focusing on PCB Prototype and PCB Assembly Turnkey Services.

One-Stop Wire Harness & Cable Assemblies Solution


Datasheet

Il modulo comprende un sensore passivo piroelettrico (PIR), e un integrato BISS0001 (integrato U4) per l’interfaccia, l'alimentazione è regolata al valore di 3,3V tramite apposito regolatore (IC1), ed è presente un diodo (D1) a protezione dell'inversione di polarità.
Sulla scheda del sensore HC-SR501 sono presenti due trimmer, uno regola la sensibilità e l'altro tempi di uscita.
Per quanto riguarda la sensibilità avremo che ruotando in senso orario => Alta sensibilità, mentre in senso antiorario => bassa sensibilità (intervallo compreso tra 3-7 m).
Per i tempi di uscita, in senso orario => lungo, antiorario => corto (intervallo compreso tra 3-300 sec)
Sul connettore d'uscita, abbiamo il polo di alimentazione Vcc (+ 5-20V), quello centrale è il pin d'uscita del segnale, mentre l'ultimo rappresenta il terminale di massa.
L'uscita è alta (3,3 V) o bassa (0 V

Caratteristiche del sensore

Il sensore di movimento PIR HC-SR501 è uno dei più facili da collegarsi ad un Arduino o a qualsiasi altro microcontrollore, tra l'altro può essere utilizzato anche come un rilevatore di movimento autonomo.
Si possono trovare due versioni della scheda. Uno con un jumper a 3 poli ed uno con piazzole di saldatura invece di un ponticello. Se il ponticello è messo nella sua posizione inferiore (con la scheda ancora di fronte, come descritto) non vi è alcun ripristino. Se è nella sua posizione superiore (H) è in modalità ripristino automatico. Se è impostato su auto-reset il segnale del sensore rimarrà alto fino a quando il movimento si arresta. Dopo, se non viene rilevato un movimento l'uscita diminuirà.
Se impostato su Nessun ripristino (L) del sensore di rilevamento si ferma una volta che ha innescato, e l'uscita rimane alta per il periodo di tempo prestabilito.
Per scegliere una di queste impostazioni, è sufficiente creare una saldatura-ponte tra il pad con l'etichetta e il pad in mezzo. il default è 'L'

Programmi di esempio

Per testare il sensore HC-SR501 sono presentati alcuni  esempi: Rilevazione di oggetto in movimento , Semplice sistema di allarme

Rilevazione di oggetto in movimento

Il primo esempio mostra la semplice attivazione del sensore con accensione di un led.  Tramite il monitor seriale viene mostrato il tempo di attivazione del sensore.
Sono necessari i seguenti componenti

Arduino UNO Sensore PIR HC-SR501 Diodo led


Programma test_sensore_pir.ino

/*  Programma:test_sensore_pir.ino 
Il programma accende un led quando un corpo caldo
è in movimento.
di Adriano Gandolfo  https://www.adrirobot.it
*/

//Definizione dei PIN
int pirPin = 2;    //il PIN di Arduino a cui è collegato il sensore
int ledPin = 13;   //il PIN a cui è connesso il LED

// Tempo di calibrazione del sensore
int calibrationTime = 30;

//Il tempo in cui l'uscita sia bassa
long unsigned int lowIn;

// valore di millisecondi, per cui si ritiene che ci sia "quiete"
long unsigned int pause = 5000;

boolean lockLow = true;
boolean takeLowTime;

// Impostazione del sensore
void setup() {
  Serial.begin(9600);
  pinMode(pirPin, INPUT);
  pinMode(ledPin, OUTPUT);
  digitalWrite(pirPin, LOW);

  //Fase di calibrazione
  Serial.print("Calibrazione del sensore ");
  for (int i = 0; i < calibrationTime; i++) {
    Serial.print(".");
    delay(1000);
  }
  Serial.println(" Fatto");
  Serial.println("SENSORE ATTIVO");
  delay(50);
}

void loop() {

  // Questo IF permette di stabilre se il sensore rileva un oggetto in movimento
  if (digitalRead(pirPin) == HIGH) {
    digitalWrite(ledPin, HIGH);   //Accendiamo il LED
    if (lockLow) {

      lockLow = false;
      Serial.println("---");
      Serial.print("Movimento rilevato a ");
      Serial.print(millis() / 1000);
      Serial.println(" sec");
      delay(50);
    }
    takeLowTime = true;
  }
  // Questo IF permette di stabilire se non c'è più nessun movimento
  if (digitalRead(pirPin) == LOW) {
    digitalWrite(ledPin, LOW);  //Si spegne il LED

    if (takeLowTime) {
      lowIn = millis();
      takeLowTime = false;
    }

    if (!lockLow && millis() - lowIn > pause) {

      lockLow = true;
      Serial.print("Movimento terminato a ");      //output
      Serial.print((millis() - pause) / 1000);
      Serial.println(" sec");
      delay(50);
    }
  }
}

Semplice sistema di allarme

Il secondo esempio rappresenta un'elementare sistema di allarme. Sono necessari i seguenti componenti

Arduino UNO Sensore PIR HC-SR501 KY-019 5V relay module
KY-006 Small passive buzzer module Diodo led  
 

Esempio di utilizzo fatto dall'amico Cristiano Rossi

 


Programma allarme_pir_HC-SR501

/*
  Programma:allarme_pir_HC-SR501.ino

  Il programma attiva un relè, accende un led e fa emettere un suono
  quando un corpo caldo è in movimento, grazie al sensore

  Creato da Adriano Gandolfo revisione 1.1 del 10/3/2019
  Sito web https://www.adrirobot.it
  Blog https://it.emcelettronica.com/author/adrirobot
  Pagina Facebook https://www.facebook.com/Adrirobot-318949048122955
  Istagram https://www.instagram.com/adrirobot/
  This example code is in the public domain.
*/

//Definizione dei PIN e variabili
int pirPin = 2;
int pinSpeaker = 3;
int pinRele = 4;
int ledPin = 13;
int pirVal = digitalRead(pirPin);

void setup() {
  Serial.begin(9600);
// Definizione pin
  pinMode(pirPin, INPUT);
  pinMode(pinSpeaker, OUTPUT);
  pinMode (pinRele, OUTPUT);
  pinMode(ledPin, OUTPUT);

  digitalWrite(pinRele, HIGH);

  Serial.println("Programma allarme con PIR");
  Serial.println("Pausa stabilizzazione sensore");
  tone(pinSpeaker, 1000, 500); //tone(pin, frequency, duration)
  delay (5000);
  Serial.println("Inizio controllo");
  tone(pinSpeaker, 500, 500);
}

void loop() {

  Serial.println("Lettura sensore PIR");
  digitalWrite(ledPin, 0);
  digitalWrite(pinRele, HIGH);
  delay(2000);
  if (pirVal == HIGH) {
    Serial.println("RILEVATO MOVIMENTO");
    digitalWrite(ledPin, HIGH);
    digitalWrite(pinRele, LOW);
    tone(pinSpeaker, 1000, 1000); //tone(pin, frequency, duration)
    delay(2000);
  }
}

Allarme con Multi Test Shield

Componenti utilizzati

Arduino UNO Multi test Shield Sensore PIR HC-SR501
KY-006 Small passive buzzer module KY-011 2 color LED module KY-019 5V relay module

Multi test Shield

Il Multi Test Shield è uno shield auto costruito realizzato per testare la serie di sensori contenuti nella confezione "37 in 1 Sensor Module Board Set" compatibile con la scheda Arduino UNO R3 originale e relativi cloni.
Sulla scheda sono disponibili molti connettori che risultano già opportunamente collegati con le porte digitali o analogiche di Arduino.
In realtà, la scheda, oltre ai sensori presenti nel kit "37 in 1 Sensor Module Board Set" permette di testare altri sensori, servo, ecc per un totale di oltre 50 tipi, la presenza di un connettore  bus I2C espande ulteriormente la tipologia di dispositivi che lo shield permette.
Sulla scheda è anche presente un connettore per il collegamento di un piccolo Display OLED da 0.95"risoluzione 96x64 pixel, 65536 Colori, su di esso potranno essere mostrati dei messaggio o i valori misurati dai sensori.

Collegamento dei modulo sullo Shield

Per l'utilizzo occorrerà semplicemente posizionare i vari componenti e in particolare

 

Modulo

Connettore
Display OLED da 0.95"risoluzione 96x64 pixel, 65536 Colori DISP1
Sensore PIR HC-SR501 JP4
KY-006 Small passive buzzer module JP8
KY-011 2 color LED module JP6
KY-019 5V relay module JP1

Schema equivalente

 

 

Programma

Il programma  accenderà in sequenza i tre led interni rosso, blu, verde in sequenza e poi simultaneamente per l'emissione della luce bianca.
Mostrerà sul display OLED le varie fasi di esecuzione del programma

Programma

allarme_pir_HC-SR501_SHIELD.ino

/*####################################################################
  FILE: allarme_pir_HC-SR501_SHIELD.ino
  VERSION: 1.0
  Quando viene rilevato un movimento viene attivayo un relè
  il led passa dal verde al rosso e viene emesso un suono
  Sul display viene segnalato lo stato del sensore

  Creato il 07/11/2018 da Adriano Gandolfo
  Sito web http://www.adrirobot.it
  Blog http://it.emcelettronica.com/author/adrirobot
  Pagina Facebook https://www.facebook.com/Adrirobot-318949048122955
  Istagram https://www.instagram.com/adrirobot/
  This example code is in the public domain.
  #################################################################### */

// Definizione dei pin di collegamento
#define sclk 13
#define mosi 11
#define cs   10
#define rst  9
#define dc   8

//Definizione dei PIN
#define pirPin 17   // pin per il sensore HC-SR501  
#define pinRele 2   // pin per il mudulo KY-019 5V relay module
#define greenpin 5  // pin per il LED verde KY-011 2 color LED module
#define redpin 6    // pin per il LED rosso KY-011 2 color LED module
#define buzzerPin 4 // Pin per il  KY-006 Small passive buzzer module

// Tempo di calibrazione del sensore
int calibrationTime = 10;

//Il tempo in cui l'uscita sia bassa
long unsigned int lowIn;

// valore di millisecondi, per cui si ritiene che ci sia "quiete"
long unsigned int pause = 3000;

boolean lockLow = true;
boolean takeLowTime;


// Definizione dei colori
#define BLACK           0x0000
#define BLUE            0x001F
#define RED             0xF800
#define GREEN           0x07E0
#define CYAN            0x07FF
#define MAGENTA         0xF81F
#define YELLOW          0xFFE0
#define WHITE           0xFFFF

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1331.h>
#include <SPI.h>

Adafruit_SSD1331 display = Adafruit_SSD1331(cs, dc, rst);

// Impostazione del sensore
void setup() {
  Serial.begin(9600);
  display.begin();
  pinMode(pirPin, INPUT);
  pinMode (pinRele, OUTPUT);
  pinMode(greenpin, OUTPUT);
  pinMode(redpin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
  digitalWrite(pirPin, LOW);

  // Messaggio iniziale
  display.fillScreen(BLACK);
  display.setTextSize(1);
  display.setTextColor(BLUE);
  display.setRotation(2); //Ruota display
  display.setCursor(0, 0);
  display.println("www.adrirobot.it");
  display.println("");
  display.setTextColor(GREEN);
  display.println("Multitest shield");
  display.println("");
  display.println("Allarme con PIR");
  display.println("Sensore HC-SR501");
  delay(2000);

  //Fase di calibrazione
  Serial.print("Calibrazione del sensore ");
  display.fillScreen(BLACK);
  display.setTextColor(BLUE);
  display.setCursor(0, 0);
  display.println("CALIBRAZIONE");

  for (int i = 0; i < calibrationTime; i++) {
    Serial.print(".");
    delay(1000);
  }
  Serial.println(" Fatto");
  Serial.println("SENSORE ATTIVO");
  display.fillScreen(BLACK);
  display.setTextColor(BLUE);
  display.setCursor(0, 0);
  display.print("SENSORE ATTIVO");
  tone(buzzerPin, 1000, 500);   //suona una nota alla frequenza di 1000Hz
  delay(1000);
  digitalWrite (redpin, LOW); // spegne led rosso
  digitalWrite (greenpin, HIGH); // accende led verde
  display.fillScreen(BLACK);
  display.setTextColor(YELLOW);
  display.setCursor(0, 0);
  display.println("STATO ALLARME");
  delay(50);
}

void loop() {

  // Questo IF permette di stabilre se il sensore rileva un oggetto in movimento
  if (digitalRead(pirPin) == HIGH) {
    digitalWrite (redpin, HIGH); // accende led rosso
    digitalWrite (greenpin, LOW); // spegne led
    digitalWrite(pinRele, HIGH);

    if (lockLow) {

      lockLow = false;
      Serial.println("---");
      Serial.print("Movimento rilevato a ");
      digitalWrite (redpin, HIGH); // accende led rosso
      digitalWrite (greenpin, LOW); // spegne led     display.fillRect(0, 45, 96, 15, BLACK);
      display.fillRect(0, 45, 96, 15, BLACK);
      display.setCursor(0, 45);
      display.setTextColor(RED);
      display.print("ALLARME");
      tone(buzzerPin, 500, 500);   //suona una nota alla frequenza di 1000Hz
      digitalWrite(pinRele, HIGH);
      Serial.print(millis() / 1000);
      Serial.println(" sec");
      delay(50);
    }
    takeLowTime = true;
  }
  // Questo IF permette di stabilire se non c'è più nessun movimento
  if (digitalRead(pirPin) == LOW) {
    digitalWrite (redpin, LOW); // spegne led rosso
    digitalWrite (greenpin, HIGH); // accende led verde
    display.fillRect(0, 45, 96, 15, BLACK);
    display.setCursor(0, 45);
    display.setTextColor(GREEN);
    display.print("NESSUNO");
    digitalWrite(pinRele, LOW);
    if (takeLowTime) {
      lowIn = millis();
      takeLowTime = false;
    }

    if (!lockLow && millis() - lowIn > pause) {

      lockLow = true;
      Serial.print("Movimento terminato a ");      //output
      Serial.print((millis() - pause) / 1000);
      Serial.println(" sec");
      delay(50);
    }
  }
}

 
Elenco revisioni

17/03/2019

Inserito versione del sistema di allarme con PIR non utilizzo Multitest shield

10/03/2019

Modificato programma, inserito filmato realizzato da Cristiano Rossi

14/09/2016

Emissione preliminare