Homework3.ino

/*
    Home Security System
    uses an ultrasonic sensor as a motion detector
    ldr controls auto-arm based on light
    buzzer + leds for alarm indication
*/

// ultrasonic distance sensor and ldr
const byte trigPin = 9;
const byte echoPin = 10;

const byte photoPin = A0;
const unsigned long trigPulseLength = 10;
const float durationToDistanceConstant = 0.034 / 2;
const unsigned long timeout = 100000;

// distance thresholds
unsigned int distanceTresholdMin = 0;
unsigned int distanceTresholdMax = 150;
unsigned int distanceTreshold = 15;
unsigned int defaultDistance = 0;
float distance = 0;
float avgDistance = 0;


// baseline ultrasonic
const int baselineReadings = 50;
unsigned int baselineCount = 0;
unsigned long baselineSum = 0;
unsigned long lastBaselineTime = 0;
const unsigned long baselineInterval = 100; // ms
bool baselineDone = false;

// small fluctuation allowance
const unsigned int fluctuation = 2; // cm

int lightTresholdMin = 100;
int lightTresholdMax = 500;
unsigned int lightTreshold = 120;

// light sensor thresholds
unsigned int lightValue = 0;
unsigned int avgLightValue = 0;

// history buffer for averaging
const int historyLength = 10;
int historyIndex = 0;

unsigned int distanceHistory[historyLength];
unsigned int lightValueHistory[historyLength];

// buzzer variables
const byte buzzerPin = 2;
const unsigned long buzzerChangeInterval = 200;
bool buzzerOn = false;
unsigned long buzzerChangeTime = 0;

int buzzerFrequency = 1000;

// red led
const byte redLedPin = 8;
const unsigned long redLedChangeInterval = 200;
bool redLedState = LOW;
unsigned long redLedChangeTime = 0;

// green led
const byte greenLedPin = 12;
bool greenLedState = HIGH;

// system states
enum 
{
  disarmed,
  armed,
  alarm,
};

const unsigned long alarmStartDelay = 3000; // delay before buzzer starts
const unsigned long startupTime = 5000; // time before first alarm allowed
const unsigned long stateUpdateDelay = 100;

byte currentState = disarmed;  // current state

unsigned long stateUpdateTime = 0;
unsigned long alarmStartTime = 0;

//main menu
enum 
{
  mainMenu,
  settingsMenu,
  passwordMenu,
  changeUltrasonicSensMenu,
  changeLightTresholdMenu,
  changeBuzzerToneMenu,
  changeSystemNameMenu,
  changePasswordMenuSecurity,
  changePasswordMenu,
};

String systemName = "Home Security";
String password = "password"; // default password

byte currentMenu = mainMenu;
String inputPassword;

// main menu input options
enum 
{
  armSystem = '1',
  triggerAlarm = '2',
  settings = '3',
};

// settings menu input
enum 
{
  changeUltrasonicSens = '1',
  changeLightTreshold = '2',
  changeBuzzerTone = '3',
  changeSystemName = '4',
  changePassword = '5',
  goBack = '0',
};

//submenu for disarm option
enum 
{
  disarmSystem = '1',
};

int input = 0; // serial input storage

// setup pins and serial
void setup() 
{
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(photoPin, INPUT);
  pinMode(buzzerPin, OUTPUT);
  pinMode(redLedPin, OUTPUT);
  pinMode(greenLedPin, OUTPUT);

  digitalWrite(greenLedPin, greenLedState);

  Serial.begin(9600);
  showMenu();
}

void loop() 
{
  recordBaseline();   // non-blocking baseline ultrasonic
  if (!baselineDone) 
     return;

  readSensors();

  if (stateUpdateTime + stateUpdateDelay < millis()) 
  {
    stateUpdateTime = millis();
    updateHistory();
  }

  if (startupTime < millis())
    updateAlarm(); // check motion and trigger alarm

  handleInput();
}

// display menu based on current state
void showMenu() 
{
  Serial.println(systemName);
  Serial.println();

  if (currentMenu == mainMenu) 
  {
    if (currentState == disarmed) 
    {
      Serial.println("1-Arm system");
      Serial.println("2-Alarm");
      Serial.println("3-Settings");
    } 
    else 
      Serial.println("1-Disarm system");
  }

  if (currentMenu == passwordMenu) 
    Serial.println("Password:");
  

  if (currentMenu == settingsMenu) 
  {
    Serial.println("1-Ultrasonic Sensitivity");
    Serial.println("2-Light Sensitivity");
    Serial.println("3-Buzzer Tone");
    Serial.println("4-System Name");
    Serial.println("5-Change Password");
    Serial.println("0-Back");
  }

  if (currentMenu == changeUltrasonicSensMenu) 
  {
    Serial.print("Current Sensitivity: ");
    Serial.print(distanceTreshold);
    Serial.println("cm");
    Serial.print("New Sensitivity (must be between ");
    Serial.print(distanceTresholdMin);
    Serial.print(" and ");
    Serial.print(distanceTresholdMax);
    Serial.println("):");
  }

  if (currentMenu == changeLightTresholdMenu) 
  {
    Serial.print("Current Sensitivity: ");
    Serial.print(lightTreshold);
    Serial.println();
    Serial.print("New Sensitivity (must be between ");
    Serial.print(lightTresholdMin);
    Serial.print(" and ");
    Serial.print(lightTresholdMax);
    Serial.println("):");
  }

  if (currentMenu == changeBuzzerToneMenu) 
  {
    Serial.print("Current Tone: ");
    Serial.print(buzzerFrequency);
    Serial.println("hz");
    Serial.println("New Tone: ");
  }

  if (currentMenu == changeSystemNameMenu) 
  {
    Serial.print("Current Name: ");
    Serial.print(systemName);
    Serial.println();
    Serial.println("New Name: ");
  }

  if (currentMenu == changePasswordMenuSecurity) 
    Serial.println("Enter current password: ");

  if (currentMenu == changePasswordMenu) 
    Serial.println("New Password: ");
}

// handle serial input and menu navigation
void handleInput() 
{
  if(Serial.available() > 0) 
  {
    if (currentState == armed || currentState == alarm) 
      if (currentMenu != mainMenu && currentMenu != passwordMenu) 
        currentMenu = mainMenu;

    if (currentMenu == mainMenu) 
    {
      input = Serial.read();
      if (currentState == disarmed) 
      {
        if (input == armSystem) 
          currentState = armed;
        
        if (input == triggerAlarm) 
        {
          currentState = alarm;
          alarmStartTime = millis();
        }
        if (input == settings) 
          currentMenu = settingsMenu;
      }
      else 
        if (input == disarmSystem)
          currentMenu = passwordMenu;
      showMenu();
      return;
    }

    if (currentMenu == settingsMenu) 
    {
      input = Serial.read();
      if (input == changeUltrasonicSens) 
        currentMenu = changeUltrasonicSensMenu;

      if (input == changeLightTreshold) 
        currentMenu = changeLightTresholdMenu;
      
      if (input == changeBuzzerTone) 
        currentMenu = changeBuzzerToneMenu;
      
      if (input == changeSystemName) 
        currentMenu = changeSystemNameMenu;
      
      if (input == changePassword) 
        currentMenu = changePasswordMenuSecurity;
      
      if (input == goBack) 
        currentMenu = mainMenu;
      
      showMenu();
      return;
    }

    if (currentMenu == changeUltrasonicSensMenu) 
    {
      input = Serial.parseInt(SKIP_NONE);
      if (input >= distanceTresholdMin && input <= distanceTresholdMax) 
        distanceTreshold = input;
      
      currentMenu = settingsMenu;
      showMenu();
      return;
    }

    if (currentMenu == changeLightTresholdMenu) 
    {
      input = Serial.parseInt(SKIP_NONE);
      if (input >= lightTresholdMin && input <= lightTresholdMax) 
        lightTreshold = input;
      
      currentMenu = settingsMenu;
      showMenu();
      return;
    }

    if (currentMenu == changeBuzzerToneMenu) 
    {
      input = Serial.parseInt(SKIP_NONE);
      buzzerFrequency = input;
      currentMenu = settingsMenu;
      showMenu();
      return;
    }

    if (currentMenu == changeSystemNameMenu) 
    {
      systemName = Serial.readString();
      currentMenu = settingsMenu;
      showMenu();
      return;
    }

    if (currentMenu == changePasswordMenuSecurity) 
    {
      inputPassword = Serial.readString();

      if(inputPassword.equals(password))
        currentMenu = changePasswordMenu;
      else 
        Serial.println("Incorrect password");
      showMenu();
      return;
    }

    if (currentMenu == changePasswordMenu) 
    {
      password = Serial.readString();
      currentMenu = settingsMenu;
      showMenu();
      return;
    }

    if (currentMenu == passwordMenu) 
    {
      inputPassword = Serial.readString();

      if(inputPassword.equals(password))
      {
        currentMenu = mainMenu;
        currentState = disarmed;
      } 
      else 
        Serial.println("Incorrect password");
      
      showMenu();
      return;
    }
    
    showMenu();
  }
}

// read baseline distance at startup
void recordBaseline() 
{
  if (!baselineDone) 
  {
    unsigned long currentMillis = millis();
    if (currentMillis - lastBaselineTime >= baselineInterval) 
    {
      lastBaselineTime = currentMillis;

      readDistance();
      baselineSum += distance;
      baselineCount++;

      Serial.print("Baseline reading ");
      Serial.print(baselineCount);
      Serial.print(": ");
      Serial.println(distance);

      if (baselineCount >= baselineReadings) 
      {
        defaultDistance = baselineSum / baselineReadings;
        Serial.print("Baseline distance established: ");
        Serial.println(defaultDistance);
        baselineDone = true;
      }
    }
  }
}

// check distance and trigger alarm
void updateAlarm() 
{
  if (!baselineDone) 
    return;  // wait for baseline

  if (currentState == disarmed) 
  {
    greenLedState = HIGH;
    digitalWrite(greenLedPin, greenLedState);
    defaultDistance = distance; 
    if (avgLightValue < lightTreshold) 
      currentState = armed;
  } 
  else 
  {
    greenLedState = LOW;
    digitalWrite(greenLedPin, greenLedState);
  }

  if (currentState == armed) 
    if (distance > defaultDistance + distanceTreshold + fluctuation || distance < defaultDistance - distanceTreshold - fluctuation) 
      {
       currentState = alarm;
        alarmStartTime = millis();
        Serial.println("Intrusion detected! Enter password:");
      }

  //alarm logic
  if (currentState == alarm) 
  {
    if (alarmStartTime + alarmStartDelay < millis()) 
    {
      if (buzzerChangeTime + buzzerChangeInterval < millis()) 
      {
        buzzerChangeTime = millis();
        buzzerOn = !buzzerOn;
        if (buzzerOn) 
          tone(buzzerPin, buzzerFrequency);
        else 
          noTone(buzzerPin);
      }
    }

    if (redLedChangeTime + redLedChangeInterval < millis()) 
    {
      redLedChangeTime = millis();
      redLedState = !redLedState;
      digitalWrite(redLedPin, redLedState);
    }
  } 
  else 
  {
    buzzerOn = false;
    noTone(buzzerPin);

    redLedState = LOW;
    digitalWrite(redLedPin, redLedState);
  }
}

// update history buffers
void updateHistory() 
{
  distanceHistory[historyIndex] = distance;
  lightValueHistory[historyIndex] = lightValue;

  historyIndex++;
  historyIndex %= historyLength;

  avgDistance = average(distanceHistory, historyLength);
  avgLightValue = average(lightValueHistory, historyLength);
}

void readSensors() 
{
  readDistance();
  lightValue = analogRead(photoPin);
}

// read ultrasonic distance
void readDistance() 
{
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

  digitalWrite(trigPin, HIGH);
  delayMicroseconds(trigPulseLength);
  digitalWrite(trigPin, LOW);

  unsigned long duration = pulseIn(echoPin, HIGH, timeout);

  if (duration > 0) 
    distance = duration * durationToDistanceConstant;
}

float average(unsigned int* arr, int n) 
{
  float avg = 0;
  for (int i = 0; i < n; i++) 
  {
    avg += arr[i];
  }
  return avg / n;
}