Praktika 7: Nutikas parkimistõkkepuu süsteem ja Iseliikuv auto

int switchPin = 2; // lüliti 1 
int motor1Pin1 = 3; // viik 2 (L293D) 

int motor1Pin2 = 4; // viik 7 (L293D) 

int enablePin = 9; // viik 1(L293D) 

 void setup() { 

 // sisendid 

 pinMode(switchPin, INPUT);

 //väljundid 

 pinMode(motor1Pin1, OUTPUT); 

 pinMode(motor1Pin2, OUTPUT); 

 pinMode(enablePin, OUTPUT); 

 // aktiveeri mootor1 

 digitalWrite(enablePin, HIGH); 

} 

 void loop() { 

 // kui lüliti on HIGH, siis liiguta mootorit ühes suunas: 

 if (digitalRead(switchPin) == HIGH) 

{ 

 digitalWrite(motor1Pin1, LOW); // viik 2 (L293D) LOW 

 digitalWrite(motor1Pin2, HIGH); // viik 7 (L293D) HIGH 

 } 

 // kui lüliti on LOW, siis liiguta mootorit teises suunas: 

 else

 { digitalWrite(motor1Pin1, HIGH); // viik 2 (L293D) HIGH 

 digitalWrite(motor1Pin2, LOW); // viik 7 (L293D) LOW 

 } 

} 

#include <Servo.h>
#include <LiquidCrystal.h>

Servo barrier;

// LCD: RS, E, DB4, DB5, DB6, DB7
LiquidCrystal lcd(12, 11, 7, 8, 2, 13);

// HC-SR04
const int trigPin = 9;
const int echoPin = 10;

// RGB LED
const int redPin = 5;
const int greenPin = 4;
const int bluePin = 3;

// Servo
const int servoPin = 6;

const int limitDistance = 15;

long duration;
int distance;

int getDistance() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);

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

  duration = pulseIn(echoPin, HIGH, 30000);

  if (duration == 0) {
    return 999;
  }

  return duration * 0.034 / 2;
}

void redLight() {
  digitalWrite(redPin, LOW);
  digitalWrite(greenPin, HIGH);
  digitalWrite(bluePin, HIGH);
}

void greenLight() {
  digitalWrite(redPin, HIGH);
  digitalWrite(greenPin, LOW);
  digitalWrite(bluePin, HIGH);
}

void showClosed() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Parkla sisse");
  lcd.setCursor(0, 1);
  lcd.print("Suletud");
}

void setup() {
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);

  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);

  barrier.attach(servoPin);
  barrier.write(0);

  lcd.begin(16, 2);

  redLight();
  showClosed();

  Serial.begin(9600);
}

void loop() {
  distance = getDistance();

  Serial.print("Distance: ");
  Serial.println(distance);

  if (distance > 0 && distance < limitDistance) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Auto leitud");
    lcd.setCursor(0, 1);
    lcd.print("Kontroll...");

    delay(1000);

    distance = getDistance();

    if (distance > 0 && distance < limitDistance) {
      barrier.write(90);
      greenLight();

      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("Tere tulemast");
      lcd.setCursor(0, 1);
      lcd.print("Avatud");

      delay(2000);
    }
  } else {
    barrier.write(0);
    redLight();
    showClosed();
  }

  delay(300);
}

// KAUGUSE MÕÕTMISE MUUTUJAD (DISTANCE VARIABLES)
const int trigPin = 8;
const int echoPin = 7;
long duration, distance;
int dist_result;

// MOOTORITE MUUTUJAD (MOTORS VARIABLES)
const int mot1f = 6;
const int mot1b = 5;
const int mot2f = 11;
const int mot2b = 10;
int mot_speed = 180; // Mootorite kiirus (0-255)
int k = 0;           // Muutuja sujuvaks pööramiseks

// LOOGIKA MUUTUJAD (LOGICS VARIABLES)
const int dist_stop = 25;   // Peatumise kaugus sentimeetrites
const int max_range = 800;  // Maksimaalne lubatud väärtus (veatuvastus)
const int min_range = 0;    // Minimaalne lubatud väärtus (veatuvastus)
int errorLED = 13;          // Integreeritud LED veateadeteks

// ESMANE SEADISTAMINE
void setup() {
  Serial.begin(9600); // Algatame jadaside andmete jälgimiseks
  
  // Sensori viikude seadistamine
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  pinMode(errorLED, OUTPUT);
  
  // Mootorite viikude seadistamine väljundiks (VÄGA OLULINE!)
  pinMode(mot1f, OUTPUT);
  pinMode(mot1b, OUTPUT);
  pinMode(mot2f, OUTPUT);
  pinMode(mot2b, OUTPUT);
}

// PÕHIPROGRAMMI TSÜKKEL
void loop() {
  int result = ping(); // Küsime andurilt praeguse kauguse

  // Kontrollime, kas anduri näit on vigane (0 või liiga suur)
  if (result <= min_range || result >= max_range) { 
    digitalWrite(errorLED, HIGH); // Süütame vea LED-i
    motors_stop();                // Ohutuse tagamiseks peatame mootorid
    delay(500);
    return;                       // Katkestame selle tsükli ja alustame loop() otsast peale
  }
  
  digitalWrite(errorLED, LOW); // Kui kõik on korras, kustutame vea LED-i

  // Loogika: mida teha takistuse korral
  if (result <= dist_stop) { 
    // Kui takistus on liiga lähedal (<= 25 cm)
    motors_stop();  // Jääme seisma
    delay(200);
    motors_back();  // Sõidame tagurpidi
    delay(1000);
    motors_stop();
    delay(200);
    motors_left();  // Pööramise manööver vasakule
    delay(300);
    motors_stop();
    delay(200);
  } else { 
    // Kui tee on vaba, sõidame otse edasi
    motors_forward();
    delay(100);     // Sõidame lühikeste sammudega, et pidevalt kaugust kontrollida
  }
}

// Abifunktsioon ÜHE mõõtmise tegemiseks
int getSingleDistance() {
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10); // Vajalik 10 mikrosekundiline impulss sensori käivitamiseks
  digitalWrite(trigPin, LOW);
  
  // pulseIn() ootab signaali HIGH. Lisatud on aegumine (timeout) 30000 mks (~4.5 meetrit),
  // et kood ei jääks seisma, kui kaja tagasi ei tule.
  long pulse_time = pulseIn(echoPin, HIGH, 30000); 
  
  if (pulse_time == 0) return 400; // Kui kaja ei tulnud, eeldame et ees on vaba tee (400 cm)
  return pulse_time / 58;          // Teisendame mikrosekundid sentimeetriteks
}

// KAUGUSE MÕÕTMISE FUNKTSIOON (3 mõõtmist ja keskmistamine)
int ping() {
  int dist1 = getSingleDistance(); delay(30);
  int dist2 = getSingleDistance(); delay(30);
  int dist3 = getSingleDistance();
  
  // Kolme arvu sorteerimine mediaani (keskmise) leidmiseks
  int middle;
  if ((dist1 <= dist2 && dist2 <= dist3) || (dist3 <= dist2 && dist2 <= dist1)) {
    middle = dist2;
  } else if ((dist2 <= dist1 && dist1 <= dist3) || (dist3 <= dist1 && dist1 <= dist2)) {
    middle = dist1;
  } else {
    middle = dist3;
  }
  
  dist_result = middle;

  Serial.print("Di: ");
  Serial.println(dist_result);
  
  return dist_result;
}

// MOOTORITE JUHTIMISE FUNKTSIOONID
void motors_forward() { 
  analogWrite(mot1f, mot_speed);
  analogWrite(mot2f, mot_speed);
  digitalWrite(mot1b, LOW);
  digitalWrite(mot2b, LOW);
}

void motors_back() { 
  digitalWrite(mot1f, LOW);
  digitalWrite(mot2f, LOW);
  analogWrite(mot1b, mot_speed);
  analogWrite(mot2b, mot_speed);
}

void motors_stop() { 
  // L298N draiveri puhul tagab kõigi viikude seadmine HIGH olekusse mootorite kiire pidurdamise
  digitalWrite(mot1f, HIGH);
  digitalWrite(mot2f, HIGH);
  digitalWrite(mot1b, HIGH);
  digitalWrite(mot2b, HIGH);
}

void motors_left() { 
  analogWrite(mot1f, mot_speed);
  digitalWrite(mot2f, LOW);
  digitalWrite(mot1b, LOW);
  analogWrite(mot2b, mot_speed);
}

void motors_right() { 
  digitalWrite(mot1f, LOW);
  analogWrite(mot2f, mot_speed);
  analogWrite(mot1b, mot_speed);
  digitalWrite(mot2b, LOW);
}

void motors_forward_left() { 
  k = mot_speed * 0.8;
  analogWrite(mot1f, mot_speed);
  analogWrite(mot2f, k);
  digitalWrite(mot1b, LOW);
  digitalWrite(mot2b, LOW);
}

void motors_forward_right() { 
  k = mot_speed * 0.8;
  analogWrite(mot1f, k);
  analogWrite(mot2f, mot_speed);
  digitalWrite(mot1b, LOW);
  digitalWrite(mot2b, LOW);
}

void motors_back_left() { 
  k = mot_speed * 0.8;
  digitalWrite(mot1f, LOW);
  digitalWrite(mot2f, LOW);
  analogWrite(mot1b, k);
  analogWrite(mot2b, mot_speed);
}

void motors_back_right() { 
  k = mot_speed * 0.8;
  digitalWrite(mot1f, LOW);
  digitalWrite(mot2f, LOW);
  analogWrite(mot1b, mot_speed);
  analogWrite(mot2b, k);
}