#include <SPI.h>            //Library Functions
#include <Wire.h>           //Library Functions
#include <Adafruit_GFX.h>  //Library Functions
#include <Adafruit_SSD1306.h>  //Library Functions

#define OLED_RESET 4        //OLED is reset
Adafruit_SSD1306 display(OLED_RESET);

int i, j, k, m, n, p, value;

int trig_pin_0 = 13;         //ULTRASONIC_SENSOR_0
int echo_pin_0 = A1;

int trig_pin_1 = A2;         //ULTRASONIC_SENSOR_1
int echo_pin_1 = A3;

int trig_pin_2 = 9;          //ULTRASONIC_SENSOR_2
int echo_pin_2 = 9; 

int duration_0, duration_1, duration_2;
int distance_0, distance_1, distance_2;
#include <SoftwareSerial.h>
SoftwareSerial GPRS(10, 11); // RX, TX

enum _parseState {
  PS_DETECT_MSG_TYPE,

  PS_IGNORING_COMMAND_ECHO,

  PS_READ_CMTI_STORAGE_TYPE,
  PS_READ_CMTI_ID,

  PS_READ_CMGR_STATUS,
  PS_READ_CMGR_NUMBER,
  PS_READ_CMGR_SOMETHING,
  PS_READ_CMGR_DATE,
  PS_READ_CMGR_CONTENT
};

byte state = PS_DETECT_MSG_TYPE;

char buffer[80];
byte pos = 0;

int lastReceivedSMSId = 0;
boolean validSender = false;

void resetBuffer() {
  memset(buffer, 0, sizeof(buffer));
  pos = 0;
}

void smartphone()
{
  GPRS.begin(9600);
  Serial.begin(9600);

  // Set as appropriate for your case
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  digitalWrite(8, HIGH);
  digitalWrite(9, HIGH);

  for (int i = 1; i <= 15; i++) {
    GPRS.print("AT+CMGD=");
    GPRS.println(i);
    delay(200);

    // Not really necessary but prevents the serial monitor from dropping any input
    while(GPRS.available()) 
      Serial.write(GPRS.read());
  }
}

void loop()
{
  while(GPRS.available()) {
    parseATText(GPRS.read());
  }
}

void parseATText(byte b) {

  buffer[pos++] = b;

  if ( pos >= sizeof(buffer) )
    resetBuffer(); // just to be safe

  /*
   // Detailed debugging
   Serial.println();
   Serial.print("state = ");
   Serial.println(state);
   Serial.print("b = ");
   Serial.println(b);
   Serial.print("pos = ");
   Serial.println(pos);
   Serial.print("buffer = ");
   Serial.println(buffer);*/

  switch (state) {
  case PS_DETECT_MSG_TYPE: 
    {
      if ( b == '\n' )
        resetBuffer();
      else {        
        if ( pos == 3 && strcmp(buffer, "AT+") == 0 ) {
          state = PS_IGNORING_COMMAND_ECHO;
        }
        else if ( pos == 6 ) {
          //Serial.print("Checking message type: ");
          //Serial.println(buffer);

          if ( strcmp(buffer, "+CMTI:") == 0 ) {
            Serial.println("Received CMTI");
            state = PS_READ_CMTI_STORAGE_TYPE;
          }
          else if ( strcmp(buffer, "+CMGR:") == 0 ) {
            Serial.println("Received CMGR");            
            state = PS_READ_CMGR_STATUS;
          }
          resetBuffer();
        }
      }
    }
    break;

  case PS_IGNORING_COMMAND_ECHO:
    {
      if ( b == '\n' ) {
        //Serial.print("Ignoring echo: ");
        //Serial.println(buffer);
        state = PS_DETECT_MSG_TYPE;
        resetBuffer();
      }
    }
    break;

  case PS_READ_CMTI_STORAGE_TYPE:
    {
      if ( b == ',' ) {
        Serial.print("SMS storage is ");
        Serial.println(buffer);
        state = PS_READ_CMTI_ID;
        resetBuffer();
      }
    }
    break;

  case PS_READ_CMTI_ID:
    {
      if ( b == '\n' ) {
        lastReceivedSMSId = atoi(buffer);
        Serial.print("SMS id is ");
        Serial.println(lastReceivedSMSId);

        GPRS.print("AT+CMGR=");
        GPRS.println(lastReceivedSMSId);
        //delay(500); don't do this!

        state = PS_DETECT_MSG_TYPE;
        resetBuffer();
      }
    }
    break;

  case PS_READ_CMGR_STATUS:
    {
      if ( b == ',' ) {
        Serial.print("CMGR status: ");
        Serial.println(buffer);
        state = PS_READ_CMGR_NUMBER;
        resetBuffer();
      }
    }
    break;

  case PS_READ_CMGR_NUMBER:
    {
      if ( b == ',' ) {
        Serial.print("CMGR number: ");
        Serial.println(buffer);

        // Uncomment these two lines to check the sender's cell number
        //validSender = false;
        //if ( strcmp(buffer, "\"+0123456789\",") == 0 )
        validSender = true;

        state = PS_READ_CMGR_SOMETHING;
        resetBuffer();
      }
    }
    break;

  case PS_READ_CMGR_SOMETHING:
    {
      if ( b == ',' ) {
        Serial.print("CMGR something: ");
        Serial.println(buffer);
        state = PS_READ_CMGR_DATE;
        resetBuffer();
      }
    }
    break;

  case PS_READ_CMGR_DATE:
    {
      if ( b == '\n' ) {
        Serial.print("CMGR date: ");
        Serial.println(buffer);
        state = PS_READ_CMGR_CONTENT;
        resetBuffer();
      }
    }
    break;

  case PS_READ_CMGR_CONTENT:
    {
      if ( b == '\n' ) {
        Serial.print("CMGR content: ");
        Serial.print(buffer);

        parseSMSContent();

        GPRS.print("AT+CMGD=");
        GPRS.println(lastReceivedSMSId);
        //delay(500); don't do this!

        state = PS_DETECT_MSG_TYPE;
        resetBuffer();
      }
    }
    break;
  }
}

void parseSMSContent() {

  char* ptr = buffer;

  while ( strlen(ptr) >= 9 ) {

    if ( ptr[0] == 'g' ) {
      if ( ptr[1] == '1' )
        digitalWrite(9, HIGH);
      else
        digitalWrite(9, LOW);
    }

    if ( ptr[0] == 'c' ) {
      if ( ptr[1] == '1' )
        digitalWrite(9, HIGH);
      else
        digitalWrite(9, LOW);
    }

    ptr += 9;
  }
}
//----------------------------------------------------

int interrupt_pin_0 = 3;      //Interrupt setup
int interrupt_pin_1 = 3;
int receiver_pin_0 = A5;      //RF Receiver setup
int receiver_pin_1 = A0;
int led_pin = 5;              //RF receiver
                              //indicator
//---------------------------------------------------
void setup()
{
  Serial.begin(9600);         //Serial monitor
                              //enabled
pinMode(trig_pin_0, OUTPUT);  //ULTRASONIC_SENSORS
pinMode(echo_pin_0, INPUT);    //setup

pinMode(trig_pin_1, OUTPUT);
pinMode(echo_pin_1, INPUT);

pinMode(trig_pin_2, OUTPUT);
pinMode(echo_pin_2, INPUT);
pinMode(led_pin, OUTPUT);

pinMode(interrupt_pin_0, OUTPUT);      //RF RECEIVER
pinMode(interrupt_pin_1, OUTPUT);
//Interrupt setup

attachInterrupt(digitalPinToInterrupt(interrupt_pin_0),gateOpen_remainOpen_0, RISING);

display.begin(SSD1306_SWITCHCAPVCC, 0x3C);

}

void ultrasonic_sensor_0()
{
  digitalWrite(trig_pin_0, HIGH);          //Read Ultrasonic sensor_0
  delayMicroseconds(10); 
  digitalWrite(trig_pin_0, LOW);
  duration_0 = pulseIn(echo_pin_0, HIGH);
  distance_0 = (duration_0/2)/29.1;
  Serial.print("1st_Sensor: ");
  Serial.print(distance_0);
  Serial.print("cm ");
}
void ultrasonic_sensor_1()
{
 digitalWrite(trig_pin_1, HIGH);         //Read Ultrasonic sensor_1
 delayMicroseconds(10);
 digitalWrite(trig_pin_1, LOW);
 duration_1 = pulseIn(echo_pin_1, HIGH);
 distance_1 = (duration_1/2)/29.1;
 Serial.print("2nd_Sensor: ");
 Serial.print(distance_1);
 Serial.print("cm ");
}
void ultrasonic_sensor_2()
{
digitalWrite(trig_pin_2, HIGH);
delayMicroseconds(10);
digitalWrite(trig_pin_2, LOW);
duration_2 = pulseIn(echo_pin_2, HIGH);
distance_2 = (duration_2/2)/29.1;
Serial.print("3nd_Sensor: ");
Serial.print(distance_2);
Serial.print("cm ");
}
void RF_receiver()
{
  
  //Serial.print("Analog Value 1 = ");    //Read RF Receiver
  //Serial.print(analogRead(receiver_pin_0));
  //Serial.print("--");
  Serial.print("Analog value 1 = ");
  Serial.println(analogRead(receiver_pin_1));
}
void interrupt_function_0()
{                                        //Interrupt function condition
if(distance_0 < 15 && distance_1 < 15)   //Motion detection Ultrasonic sensors
{                               
  OLED_vehicle_detected();
  display.clearDisplay();
  digitalWrite(interrupt_pin_0, HIGH);
}
else
{
  digitalWrite(interrupt_pin_0, LOW);
}
}
void interrupt_function_1()
{                                      //Interrupt function condition
if(analogRead(receiver_pin_1)>350)     //RF Receiver
{
  digitalWrite(interrupt_pin_1, HIGH);
}
else
{
  digitalWrite(interrupt_pin_1, LOW);
}
}
void OLED_welcome()
{
  display.clearDisplay();            //OLED display initial message setup
  display.setTextColor(WHITE);
  display.setTextSize(1);
  display.setCursor(13,5);
  display.println(" PARKING GATE");
  display.setCursor(8,16);
  display.print("CONTROLLER SYSTEM");
  display.display();
}
void OLED_vehicle_detected()
{
  display.clearDisplay();     //OLED display message for child detection
  display.setTextColor(WHITE);
  display.setTextSize(1);
  display.setCursor(15,10);
  display.print("VEHICLE DETECTED");
  display.display();
}
void OLED_gate_opening()
{                             //OLED display message for gate opening
display.clearDisplay();
display.setTextColor(WHITE);
display.setTextSize(1);
display.setCursor(0,10);
display.print("GATE IS OPENING-->");
display.println(i);
display.display();
}
void OLED_gate_opened_completely()
{
  display.clearDisplay();     //OLED display message for gate opened position
  display.setTextColor(WHITE);
  display.setTextSize(1);
  display.setCursor(0,5);
  display.println("GATE IN");
  display.print("OPEN POSITION-->");
  display.println(j);
  display.display();
}
void OLED_gate_closing()
{
  display.clearDisplay();     //OLED display message for gate closing
  display.setTextColor(WHITE);
  display.setTextSize(1);
  display.setCursor(0,5);
  display.print("GATE IS CLOSING-->");
  display.println(k);
  display.display();
}
void OLED_obstacle_detected()
{
  display.clearDisplay();    //OLED display message for obstacle detection
  display.setTextColor(WHITE);
  display.setTextSize(1);
  display.setCursor(0,5);
  display.print("OBSTACLE DETECTED-->");
  display.println(m);
  display.display();
}
void OLED_remote_pressed()
{
  display.clearDisplay();     //OLED display message if RF remote is pressed
  display.setTextColor(WHITE);
  display.setTextSize(1);
  display.setCursor(0,5);
  display.print("REMOTE PRESSED-->");
  display.println(p);
  display.display();
}
void oled_display()               //OLED display
{                         //clear display
  OLED_welcome();
  display.clearDisplay();
  ultrasonic_sensor_0();
  ultrasonic_sensor_1();
  RF_receiver();
  interrupt_function_0();
  interrupt_function_1();
  delay(1000);
}
void gate_opening()
{
  for(i=0;i<=10;i++)
  {
    interrupts();        //Gate opening function
    digitalWrite(led_pin, HIGH);  //declaration
    delay(900);         //10 seconds
    digitalWrite(led_pin, LOW);
    delay(100);
    Serial.print("GATE IS OPENING-->");
    Serial.println(i);
    OLED_gate_opening();
  }
  display.clearDisplay();
}
void gate_opened_completely()
{
  for(j=0;j<=10;j++)
  {                          //Gate opening position
    digitalWrite(led_pin, HIGH);   //Declaration
    delay(900);              //waits in the open position for
    digitalWrite(led_pin, LOW);  //10 seconds
    delay(10);
    Serial.print("GATE IN OPEN POSITION--->");
    Serial.println(j);
    OLED_gate_opened_completely();
  }
  display.clearDisplay();
}
void gateOpen_remainOpen_0()
{                          //interrupt call function
  gate_opening();          //performs 3 operations
  gate_opened_completely(); //if interrupt is called
  gate_closing();           //gate opening
}                           //gate is open completely
void gateOpen_remainOpen_1() //gate closing
{
  gate_opening();
  gate_opened_completely();
  gate_closing();
}
void gate_closing()
{                         //gate closing function
  for(k=0; k<=10; k++)
  {
    interrupts();
    digitalWrite(led_pin, HIGH);
    delay(100);
    digitalWrite(led_pin, LOW);
    delay(900);
    Serial.print("GATE IS CLOSING--->");
    Serial.println(k);
    ultrasonic_sensor_0();
    ultrasonic_sensor_1();
    RF_receiver();
    OLED_gate_closing();
    if(distance_2 < 18)           //ultrasonic sensor detects
    {                             //obstacles when closing
      for(m=k;m>=0;m--)           //performs 2 operations
      {
        interrupts();
        digitalWrite(led_pin, HIGH);
        delay(900);
        digitalWrite(led_pin, LOW);
        delay(100);
        Serial.print("GATE IS OPENING--->");   //gate opening
        Serial.println(m);
        OLED_obstacle_detected();
        delay(250);
        display.clearDisplay();
        display.setTextColor(WHITE);
        display.setTextSize(1);
        display.setCursor(0,10);
        display.print("GATE IS OPENING-->");    //gate opening completely
        display.println(n);
        display.display();
      }
      display.clearDisplay();
      k=0;
    }
    else if(analogRead(receiver_pin_1)>350)     //RF receiver
    {
      for(p=k;p>=0;p--)
      {
        interrupts();
        digitalWrite(led_pin, HIGH);
        delay(900);
        digitalWrite(led_pin, LOW);
        delay(100);
        Serial.print("GATE IS OPENING--->");
        Serial.println(p);
        OLED_remote_pressed();
        delay(250);
        display.clearDisplay();
        display.setTextColor(WHITE);
        display.setTextSize(1);
        display.setCursor(0,10);
        display.print("GATE IS OPENING-->");
        display.println(p);
        display.display();
      }
      display.clearDisplay();
      gate_opened_completely();
      k=0;
    }
    else
    {
    }
  }
}