Sensore infrarosso PIR compatto AM312

In questo articolo analizzeremo sensore infrarosso PIR AM312 (vedere datasheet) versione miniaturizzata del Sensore infrarosso PIR HC-SR501 già analizzato in un precedente articolo.

Citazione dell’articolo nelle sezioni ARDUINO, ARTICOLI, PROGETTI del blog di Elettronica In

Indice

Sensore PIR AM312

I sensori infrarosso di tipo PIR acronimo di Passive InfraRed, sono sensori elettronici che rilevano la radiazione infrarossa (IR) irradiata dagli oggetti nel loro campo visivo. Molto usati come rilevatori di movimento.
Vedere anche articolo Cos’è un sensore infrarosso passivo PIR
Nel nostro caso si tratta di un modulo ultracompatto con sensore PIR in miniatura tipo AM312 (vedere datasheet), scheda di controllo con uscita da interfacciare ad un microcontrollore, Arduino, etc. (livello alto 3 V – basso 0 V).
Tempo di ritardo 2 secondi (non impostabile), consumo a riposo inferiore a 0,1 mA, angolo di rilevamento di 100°, portata massima 5 metri.
Dispone solamente di tre piedini (uscita, positivo e negativo di alimentazione).
NOTA: il sensore AM312 si trova anche come AS312 (datasheet)

Caratteristiche del sensore

Alimentazione:	da 3 a 12 VDC
Consumo a riposo:	< 0,1 mA
Uscita:	livello alto 3 V / basso 0V
Distanza di rilevamento:	max. circa 5 metri
Angolo di rilevamento:	< 100° a circa 3,5 metri
Tempo di ritardo:	circa 2 secondi (non impostabile)
Dimensioni (lunghezza x diametro) (mm):	20x13
Peso:	1,5 grammi
Temperatura di funzionamento:	da -20°C a +60°C

Circuito elettrico

Il circuito elettrico del modulo sensore infrarosso PIR AM312 è molto semplice, tutte le funzioni sono svolte dal sensore U1 tipo AM312 (vedere datasheet), nel circuito è presente solamente un regolatore di tensione, U2 tipo HT7530 che riduce il valore della tensione in ingresso al valore di 3.3V, valore massimo per il sensore. Sono poi presenti dei condensatori per il livellamento della tensione e una resistenza dal valore di 20 kΩ posta sulla line OUT.

Datasheet

Pin di collegamento

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).

Dove trovare il sensore PIR

Il sensore PIR può essere acquistato presso il sito FUTURA ELETTRONICA. Il codice prodotto è 8300-YB717 , il suo costo, al momento della pubblicazione di questo articolo è di 5,50 €.
Citazione dell’articolo nella sezione ARDUINO, ARTICOLI, PROGETTI di Elettronica In

Rilevazione di oggetto in movimento

Lo schema e il codice utilizzato per i test è molto semplice.
Pe la segnalazione è utilizzato un modulo Traffic light, simile ad un semaforo, normalmente sarà acceso il LED Verde, mentre in caso di rilevamento di un movimento si accenderà il LED Rosso.
nel codice dobbiamo solo definire il pin del sensore PIR come ingresso e i LED come uscita, un pin sarà utilizzato per collegare a GND il modulo Traffic light, e permettere l’accensione dei led. Per questa applicazione non si utilizza il led giallo.
Utilizzando poi la funzione digitalRead() leggeremo l’uscita del sensore PIR e se è alta o se viene rilevato un oggetto accenderà il LED rosso e invierà il messaggio al monitor Serial, il LED Verde sarà spento.
Il LED Verde sarà acceso quando il LED Rosso sarà spento se non viene rilevato nulla.

Materiale necessario

Sono necessari i seguenti componenti

Arduino UNO

Modulo semaforo

Sensore PIR AM312

Codice Ks0310

Modulo semaforo

Il modulo Traffic Light Module utilizzato nel progetto è prodotto dalla keystudio Codice Ks0310.
Questo si trova tra l’altro all’interno del Kit Keyestudio 37 in 1 Starter Kit per BBC micro:bit

Il Kit può essere acquistato presso Amazon, o AliExpress. Il codice dell’articolo è ks0361

Acquisto presso Amazon	Acquisto presso AliExpress

Schema dei collegamenti

Istruzioni passo passo

Aprire l’IDE di Arduino ;
Collegare la scheda Arduino Uno al PC e selezionare la scheda e la porta COM corretta;
Aprire il monitor seriale e impostare il baud su 9600 baud;
Verificare e caricare lo sketch sulla scheda Arduino Uno;
Se il sensore PIR rileva un movimento accende il LED rosso e invia il messaggio al monitor seriale, il LED verde si spegne. Il LED verde sarà acceso e il LED rosso sarà spento se non viene rilevato nulla.
Si noti che dopo aver alimentato il modulo sensore sono necessari circa 10 – 60 secondi per “riscaldarsi” per funzionare correttamente, il valore può essere modificato all’interno del codice.

Codice utilizzato

//*******************************************************************************
int calibrationTime = 10;        // il tempo di calibrazione per il sensore 10-60 secondi)
long unsigned int lowIn;         //tempo in cui il sensore emette un impulso basso
long unsigned int pause = 5000;  //il numero di millisecondi in l'uscita deve essere basso
//si assume che non vi siano movimenti
boolean lockLow = true;
boolean takeLowTime;
const int pirPin = 2;      //pin a cui è collegato il sensore PIR
const int redledPin = 11;  //pin a cui è collegato il LED rosso
const int greenledPin = 9; //pin a cui è collegato il LED verde
const int GND = 8; //pin a cui è collegato GND del modulo Traffic light

//****************************************************************************
void setup() {
  Serial.begin(9600);            //initializa al comunicazione seriale a 9600 bps
  pinMode(pirPin, INPUT);        //impoasta pirPin come INPUT
  pinMode(redledPin, OUTPUT);    //imposta redledPin come OUTPUT
  pinMode(greenledPin, OUTPUT);  //imposta greenledPin come OUTPUT
  pinMode(GND, OUTPUT); ////imposta GND come OUTPUT
  digitalWrite(GND, LOW);// imposta a LOW il pin GND
  digitalWrite(pirPin, LOW);     //per default, nessun movimento

  Serial.print("Inizia calibrazione del sensore PIR ");  //Attesa per calibrazione
  for (int i = 0; i < calibrationTime; i++) { //loop da 0 al tempo di calibrazione impostato
    Serial.print(".");
    delay(1000);//imposta attesa di 1 secondo
  }
  Serial.println("Calibrazione eseguita");
  Serial.println("SENSORE PIR ATTIVO");
  delay(50);//pausa di 50ms
}
void loop() {
  int sensorValue = digitalRead(pirPin);//legge lo stato del sensore PIR
  if (sensorValue == HIGH) {
    digitalWrite(redledPin, HIGH); //Accende LED rosso
    digitalWrite(greenledPin, LOW);//Spegne LER verde
    if (lockLow) {
      lockLow = false;
      //si assicura di attendere una transizione a LOW prima di un ulteriore output:
      Serial.println("---");
      Serial.print("Movimento rilevato a ");
      Serial.print(millis() / 1000);
      Serial.println(" sec");
      delay(50);//pausa di 50ms
    }
    takeLowTime = true;
  }
  if (sensorValue == LOW) {
    digitalWrite(redledPin, LOW);   //Spegna LED rossso
    digitalWrite(greenledPin, HIGH);//Accende LED verde
    if (takeLowTime) {
      lowIn = millis();          //salva il tempo di transizione da alto a BASSO
      takeLowTime = false;       //si assicura che ciò avvenga solo all'inizio di una fase LOW
    }
    //se il sensore è basso per più della pausa indicata, assumiamo che vi siano più movimenti
    if (!lockLow && millis() - lowIn > pause) {
      //si assicura che questo blocco di codice venga eseguito di nuovo solo dopo
      lockLow = true;//è stata rilevata una nuova sequenza di movimenti
      Serial.print("Il movimento è terminato dopo ");
      Serial.print((millis() - pause) / 1000);
      Serial.println(" sec");
      delay(50);//pausa di 50ms
    }
  }
}

//*******************************************************************************

int calibrationTime = 10; // il tempo di calibrazione per il sensore 10-60 secondi)

long unsigned int lowIn; //tempo in cui il sensore emette un impulso basso

long unsigned int pause = 5000; //il numero di millisecondi in l'uscita deve essere basso

//si assume che non vi siano movimenti

boolean lockLow = true;

boolean takeLowTime;

const int pirPin = 2; //pin a cui è collegato il sensore PIR

const int redledPin = 11; //pin a cui è collegato il LED rosso

const int greenledPin = 9; //pin a cui è collegato il LED verde

const int GND = 8; //pin a cui è collegato GND del modulo Traffic light

//****************************************************************************

void setup() {

Serial.begin(9600); //initializa al comunicazione seriale a 9600 bps

pinMode(pirPin, INPUT); //impoasta pirPin come INPUT

pinMode(redledPin, OUTPUT); //imposta redledPin come OUTPUT

pinMode(greenledPin, OUTPUT); //imposta greenledPin come OUTPUT

pinMode(GND, OUTPUT); ////imposta GND come OUTPUT

digitalWrite(GND, LOW);// imposta a LOW il pin GND

digitalWrite(pirPin, LOW); //per default, nessun movimento

Serial.print("Inizia calibrazione del sensore PIR "); //Attesa per calibrazione

for (int i = 0; i < calibrationTime; i++) { //loop da 0 al tempo di calibrazione impostato

Serial.print(".");

delay(1000);//imposta attesa di 1 secondo

}

Serial.println("Calibrazione eseguita");

Serial.println("SENSORE PIR ATTIVO");

delay(50);//pausa di 50ms

}

void loop() {

int sensorValue = digitalRead(pirPin);//legge lo stato del sensore PIR

if (sensorValue == HIGH) {

digitalWrite(redledPin, HIGH); //Accende LED rosso

digitalWrite(greenledPin, LOW);//Spegne LER verde

if (lockLow) {

lockLow = false;

//si assicura di attendere una transizione a LOW prima di un ulteriore output:

Serial.println("---");

Serial.print("Movimento rilevato a ");

Serial.print(millis() / 1000);

Serial.println(" sec");

delay(50);//pausa di 50ms

}

takeLowTime = true;

}

if (sensorValue == LOW) {

digitalWrite(redledPin, LOW); //Spegna LED rossso

digitalWrite(greenledPin, HIGH);//Accende LED verde

if (takeLowTime) {

lowIn = millis(); //salva il tempo di transizione da alto a BASSO

takeLowTime = false; //si assicura che ciò avvenga solo all'inizio di una fase LOW

}

//se il sensore è basso per più della pausa indicata, assumiamo che vi siano più movimenti

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

//si assicura che questo blocco di codice venga eseguito di nuovo solo dopo

lockLow = true;//è stata rilevata una nuova sequenza di movimenti

Serial.print("Il movimento è terminato dopo ");

Serial.print((millis() - pause) / 1000);

Serial.println(" sec");

delay(50);//pausa di 50ms

}