Parking Proximity Sensor

void setup() 

{
    pinMode(D7,OUTPUT);
    Particle.subscribe("MEGR3171_sensorstatus_528","Clear",lowfunc);
    Particle.subscribe("MEGR3171_sensorstatus_528","Breach",highfunc);
    
}


int lowfunc(const char *topic, const char *data)
{
    tone(D7,0,0); //buzzer off
}

int highfunc(const char *topic, const char *data)
{
    tone(D7,2000,3000); //buzzer on
}

// This #include statement was automatically added by the Particle IDE.
#include "hc-sr04.h"

// Sensor gateway using the Argon board. This contains the HC-SR04
// Ultrasonic code and sends data to the other nodes to notify of a trip

double cm = 0.0;
bool beam_status = false;

int trigPin = D4;
int echoPin = D5;

HC_SR04 rangefinder = HC_SR04(trigPin, echoPin);

void setup() 
{
    Spark.variable("cm", &cm, DOUBLE);
    pinMode(trigPin, OUTPUT);
    pinMode(echoPin, INPUT);
}

void loop() 
{
    cm = rangefinder.distCM();
    if (cm<50){
        if (beam_status==false){
            
            Particle.publish("MEGR3171_sensorstatus_528","Breach");
            beam_status = true;   
        }
    } else {
        if (beam_status==false){
            
        } else {
            Particle.publish("MEGR3171_sensorstatus_528","Clear");
            beam_status = false;
        }
    }
    delay(1000);
}

//
//    HC-SR04.cpp
//    Purpose: Implementation of the HC-SR04 driver
//
//    Author: Richard Nash
//    Version: 1.0.1

#include "hc-sr04.h"
#include "Particle.h"

HC_SR04::HC_SR04(int trigPin, int echoPin)
{
    this->trigPin = trigPin;
    this->echoPin = echoPin;
}

void HC_SR04::init()
{
    pinMode(trigPin, OUTPUT);
    pinMode(echoPin, INPUT);
}

float HC_SR04::distCM()
{
    // Speed of sound is approx 343 m/s
    // 343 m/s * 100 cm/m * 0.000001 s/us / 2.0 trips
    const float uSecondsToCM = ((340.0f * 100.0 * 0.000001f) /  2.0f);
    unsigned long timeUntilLow = triggerAndMeasurePulse();
    if (timeUntilLow == 0) return NO_SIGNAL;
    return (float)timeUntilLow * uSecondsToCM;
}

float HC_SR04::distInch()
{

    // Speed of sound at 70 degrees F is approximately 1128 ft/s
    // 1128 ft/s * 12 inch/ft * 0.000001 s/us / 2.0 trips
    const float uSecondsToInch = ((1128.0f * 12.0 * 0.000001f) /  2.0f);
    unsigned long timeUntilLow = triggerAndMeasurePulse();
    if (timeUntilLow == 0) return NO_SIGNAL;
    return (float)timeUntilLow * uSecondsToInch;
}

unsigned long HC_SR04::triggerAndMeasurePulse()
{
    // Response pulse usually starts in under 500 uSecs, wait up to 2ms to be sure.
    const unsigned long timeoutHigh = 2000;
    // Response pulse should be shorter than about 29ms (allow 5 meter as limit)
    const unsigned long timeoutLow = 29000;
    unsigned long start, duration;

    // Timing is crucial here, so cannot allow other threads or interrupts
    // Maximum ammount of time in this block is limitted to 10 + 2,000 + 29,000 uS
    // Or 31 milliseconds
    ATOMIC_BLOCK() {
        // Send the 10 uSec pulse
        pinSetFast(trigPin);
        delayMicroseconds(10);
        pinResetFast(trigPin);

        start = micros();
        while (pinReadFast(echoPin) != HIGH) {
            duration = micros() - start;
            if (duration >= timeoutHigh) {
                // Didn't recieve a pulse
                return 0;
            }
        }

        start = micros();
        while (pinReadFast(echoPin) != LOW) {
            duration = micros() - start;
            if (duration >= timeoutLow) {
                // Pulse lasted longer than the 4 meter range limit
                return 0;
            }
        }
        return duration;
    }
}

//
//    HC-SR04.h
//    Purpose: HC-SR04 driver
//
//    Author: Richard Nash
//    Version: 1.0.1

// This class provides the trigger and timing to use the range
// finder. See the usage example in this library for how to use it.

#pragma once

 class HC_SR04
 {
 public:
   // No default Constructor, need to specify the pins
   HC_SR04() = delete;

   // Constructor
   // Parameters:
   // trigPin : The pin the Trig signal is connected to
   // echoPin : The pin the Echo signal is connected to
   HC_SR04(int trigPin, int echoPin);

   // Call this function in the setup() routine to set the pin modes.
   void init();

   // NOTE: Both distCM() and distInch() block threading AND interrupts for a
   // short period of time. That time can be up to approximately 31 milliseconds

   // Returns the range distance in centimeters OR NO_SIGNAL if range finding
   // failed.
   float distCM();

   // Returns the range distance in inches OR NO_SIGNAL if range finding
   // failed.
   float distInch();

   // Sentinal value for no distance returned
   const float NO_SIGNAL = -1.0f;

 private:
   int trigPin;
   int echoPin;
   unsigned long triggerAndMeasurePulse();
 };