PIRSensor.h

Go to the documentation of this file.

// src/PIRSensor.h
#ifndef PIRSENSOR_H
#define PIRSENSOR_H
 
#include "ISensor.h"
#include "Particle.h"
#include "device_pinout.h"
#include "MyPersistentData.h"  // for sysStatus (verboseMode)

class PIRSensor : public ISensor {
public:
    static PIRSensor& instance() {
        static PIRSensor _instance;
        return _instance;
    }

    bool setup() override {
        // Configure PIR-related pins from device_pinout
        pinMode(intPin, INPUT_PULLDOWN);   // PIR interrupt output with pull-down
        pinMode(disableModule, OUTPUT);    // Sensor enable line (active LOW)
        pinMode(ledPower, OUTPUT);         // Sensor indicator LED power
 
        // Enable sensor and LED by default
        digitalWrite(disableModule, LOW);  // Bring low to turn sensor ON
        digitalWrite(ledPower, LOW);       // Active-LOW: bring low to turn LED ON
 
        // Attach interrupt on RISING edge (PIR output is active-high).
        attachInterrupt(intPin, pirISR, RISING);
 
        reset();           // Ensure SensorData is initialized
        _isReady = true;   // Mark as ready
        return true;       // Return true so device doesn't reset
    }

    bool loop() override {
        if (!_isReady) {
            return false;
        }
 
        // If no motion flag, nothing to report
        if (!_motionDetected) {
            return false;
        }
 
        // Clear flag and apply debounce: ignore events within 500 ms
        _motionDetected = false;
        unsigned long nowMs = millis();
        if (nowMs - _lastEventMs < 500) {
            return false;
        }
        _lastEventMs = nowMs;
 
        _data.timestamp = Time.now();
        _data.hasNewData = true;
        return true;
    }

    SensorData getData() const override {
        return _data;
    }

    const char* getSensorType() const override {
        return "PIR";  // String literal, no allocation
    }

    bool isReady() const override {
        return _isReady;
    }

    void reset() override {
        _data = SensorData();
        strncpy(_data.sensorType, "PIR", sizeof(_data.sensorType) - 1);
        _data.sensorType[sizeof(_data.sensorType) - 1] = '\0';
        // Clear any pending motion
        _motionDetected = false;
    }

    bool usesInterrupt() const override { return true; }

    void onSleep() override {
        if (!_isReady) {
            return;
        }
 
        detachInterrupt(intPin);
        digitalWrite(disableModule, HIGH); // Disable sensor module
        digitalWrite(ledPower, HIGH);      // Active-LOW: bring high to turn LED OFF
        _isReady = false;
        Log.info("PIR sensor powered down for sleep");
    }

    bool onWake() override {
        // For ULTRA_LOW_POWER naps we normally keep the PIR powered
        // and its interrupt attached across sleep so it can wake the
        // MCU. In that case we should NOT clear the motion flag here,
        // otherwise the wake-causing event is lost before the main
        // loop can count it.
 
        pinMode(disableModule, OUTPUT);
        pinMode(ledPower, OUTPUT);
        pinMode(intPin, INPUT_PULLDOWN);
 
        digitalWrite(disableModule, LOW);
        digitalWrite(ledPower, LOW);       // Active-LOW: LED ON after wake
 
        attachInterrupt(intPin, pirISR, RISING);
 
        _isReady = true;
        Log.info("PIR sensor powered up after wake (interrupt attached)");
        return true;
    }
 
private:
    PIRSensor() : _isReady(false) {
        strncpy(_data.sensorType, "PIR", sizeof(_data.sensorType) - 1);
        _data.sensorType[sizeof(_data.sensorType) - 1] = '\0';  // Ensure null termination
    }
    ~PIRSensor() {}
    
    // Prevent copying
    PIRSensor(const PIRSensor&) = delete;
    PIRSensor& operator=(const PIRSensor&) = delete;
 
    bool _isReady;
    SensorData _data;
 
    // Debounce state: last accepted motion event time (ms)
    unsigned long _lastEventMs = 0;
 
    // PIR-specific state
    static volatile bool _motionDetected;  // Set by ISR, read/cleared in loop()
    static volatile uint32_t _isrCount;    // Counts how many times ISR fired
 
    // ISR handler
    static void pirISR();
};
 
#endif /* PIRSENSOR_H */