Sensoren-Puzzle mit Arduino: Unterschied zwischen den Versionen

Aus HSHL Mechatronik
Zur Navigation springen Zur Suche springen
Zeile 160: Zeile 160:
<br>
<br>
<br>
<br>
<br>
'''Hier ist der Code, der die Grundlage unseres Projekts bildet:'''
<br>
<div style="width:1200px; height:1000px; overflow:scroll; border: hidden">
<br>
<syntaxhighlight lang="cpp" style="border: none; background-color: #EFF1C1; font-size:larger">
<br>
 
<br>
 
<br>
/*****************************************************************************
<br>
Autoren:  Maha Chraiji, Oluwatobiloba Oguntona                              *
<br>
Programm:  Sensoren-Puzzle mit Arduino                                      *
<br>
Modul:    Fachpraktikum Elektrotechnik                                      *
Betreuer:  Professor Göbel                                                  *
Semester:  Wintersemester 2024/2025                                          *
*****************************************************************************/
 
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
 
// Initialize I2C LCD (use the detected address, usually 0x27 or 0x3F)
LiquidCrystal_I2C lcd(0x27, 16, 2); // Address, columns, rows
 
// Pin definitions for sensors
const int lightSensorPin = A0;
const int tempSensorPin = A1;
const int distanceTriggerPin = 3;
const int distanceEchoPin = 2;
 
// RGB LED pins
const int rgbRedPin = 6;
const int rgbGreenPin = 5;
const int rgbBluePin = 4;
 
// Reset button pin
const int resetButtonPin = 7;
 
// Target values and tolerances
const int targetLight = 0; // As dark as a room can get
const int lightTolerance = 5;
const float targetTemp = 24.0; // Average finger tip temperature
const float tempTolerance = 2.0;
const float targetDistance = 8.0;
const float distanceTolerance = 1.0;
 
// Task completion flags
bool tasksCompleted[3] = {false, false, false};
 
void setup() {
  // Initialize LCD
  lcd.init();        // Initialize the LCD
  lcd.backlight();  // Turn on the LCD backlight
 
  // Initialize RGB LED pins
  pinMode(rgbRedPin, OUTPUT);
  pinMode(rgbGreenPin, OUTPUT);
  pinMode(rgbBluePin, OUTPUT);
 
  // Initialize distance sensor pins
  pinMode(distanceTriggerPin, OUTPUT);
  pinMode(distanceEchoPin, INPUT);
 
  // Initialize reset button pin
  pinMode(resetButtonPin, INPUT_PULLUP);
 
  // Start message
  lcd.print("Awaken the");
  lcd.setCursor(0, 1);
  lcd.print("Guardian...");
  delay(5000);
  lcd.clear();
}
 
void loop() {
  // Ensure tasks run only if they are incomplete
  if (!tasksCompleted[0] && checkLightSensor()) {
    tasksCompleted[0] = true;
    lcd.clear();
    lcd.print("Eye of Light");
    lcd.setCursor(0, 1);
    lcd.print("Activated!");
    activateRGB(255, 255, 255); // White light
    delay(5000);
    deactivateRGB();
  } else if (!tasksCompleted[0]) {
    lcd.clear();
    lcd.print("Light incorrect");
    lcd.setCursor(0, 1);
    lcd.print("Adjust light!");
    delay(1000);
  }
 
  if (!tasksCompleted[1] && checkTempSensor()) {
    tasksCompleted[1] = true;
    lcd.clear();
    lcd.print("Eye of Fire");
    lcd.setCursor(0, 1);
    lcd.print("Activated!");
    activateRGB(255, 0, 0); // Red light
    delay(5000);
    deactivateRGB();
  } else if (!tasksCompleted[1]) {
    lcd.clear();
    lcd.print("Temp incorrect");
    lcd.setCursor(0, 1);
    lcd.print("Adjust temp!");
    delay(1000);
  }
 
  if (!tasksCompleted[2] && checkDistanceSensor()) {
    tasksCompleted[2] = true;
    lcd.clear();
    lcd.print("Eye of Space");
    lcd.setCursor(0, 1);
    lcd.print("Activated!");
    activateRGB(0, 0, 255); // Blue light
    delay(5000);
    deactivateRGB();
  } else if (!tasksCompleted[2]) {
    lcd.clear();
    lcd.print("Distance wrong");
    lcd.setCursor(0, 1);
    lcd.print("Adjust pos!");
    delay(1000);
  }
 
  // Check if all tasks are completed
  if (tasksCompleted[0] && tasksCompleted[1] && tasksCompleted[2]) {
    lcd.clear();
    lcd.print("Guardian's");
    lcd.setCursor(0, 1);
    lcd.print("Secret Revealed!");
    victorySequence();
    delay(10000);
 
    // Wait for reset button to be pressed
    while (true) {
      if (digitalRead(resetButtonPin) == HIGH) {
        resetSystem();
        break;
      }
    }
  }
}
 
// Light sensor check
bool checkLightSensor() {
  int lightValue = analogRead(lightSensorPin);
  return abs(lightValue - targetLight) <= lightTolerance;
}
 
// Temperature sensor check
bool checkTempSensor() {
  int tempValue = analogRead(tempSensorPin);
  float voltage = tempValue * 5.0 / 1023.0;
  float tempC = (voltage - 0.5) * 100;
  return abs(tempC - targetTemp) <= tempTolerance;
}
 
// Distance sensor check
bool checkDistanceSensor() {
  digitalWrite(distanceTriggerPin, LOW);
  delayMicroseconds(2);
  digitalWrite(distanceTriggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(distanceTriggerPin, LOW);
 
  long duration = pulseIn(distanceEchoPin, HIGH);
  float distance = duration * 0.034 / 2; // Convert to cm
  return abs(distance - targetDistance) <= distanceTolerance;
}
 
// RGB LED control
void activateRGB(int red, int green, int blue) {
  analogWrite(rgbRedPin, red);
  analogWrite(rgbGreenPin, green);
  analogWrite(rgbBluePin, blue);
}
 
void deactivateRGB() {
  analogWrite(rgbRedPin, 0);
  analogWrite(rgbGreenPin, 0);
  analogWrite(rgbBluePin, 0);
}
 
// Victory sequence for RGB LED
void victorySequence() {
  for (int i = 0; i < 3; i++) {
    activateRGB(0, 255, 0); // Green light
    delay(500);
    deactivateRGB();
    delay(500);
  }
}
 
// Reset system to initial state
void resetSystem() {
  // Reset task completion flags
  for (int i = 0; i < 3; i++) {
    tasksCompleted[i] = false;
  }
 
  // Clear LCD and show start message
  lcd.clear();
  lcd.print("Awaken the");
  lcd.setCursor(0, 1);
  lcd.print("Guardian...");
  delay(5000);
  lcd.clear();
 
  // Deactivate RGB LED
  deactivateRGB();
}
 
</syntaxhighlight>
</div>
<br clear=all>
</div>
<br>
<br>
<br>
<br>

Version vom 16. Januar 2025, 23:31 Uhr

Autor: Maha Chraiji und Oluwatobiloba Oguntona
Betreuer: Prof. Schneider oder Prof. Göbel oder Marc Ebmeyer

Autor: Maha Chraiji und Oluwatobiloba Oguntona

Projektübersicht

Dieses interaktive Projekt verwendet ein Arduino, das mit drei verschiedenen Sensoren verbunden ist: einem Lichtsensor, einem Temperatursensor und einem Distanzsensor. Die Teilnehmer müssen spezifische Aktionen durchführen, um jeden Sensor zu aktivieren.

Die Lichtintensität auf dem Lichtsensor verringern.
Den Temperatursensor durch Berührung erwärmen.
Ihre Hand in der Nähe des Distanzsensors bewegen.
Jeder Sensor steuert einen Teil der Informationen, die auf einem 16x2 LCD-Bildschirm angezeigt werden. Wenn alle drei Sensoren korrekt aktiviert werden, zeigt das LCD die Lösung des Rätsels an.

Projektkomponenten

Arduino: Mikrocontroller, der die Sensoreingaben verarbeitet und das Display steuert.
Lichtsensor : Erkennt Lichtniveaus.
Temperatursensor : Misst Temperaturänderungen.
Distanzsensor: Misst die Nähe mit Ultraschall.
16x2 LCD-Display: Zeigt Textnachrichten basierend auf den Sensoreingaben an.
Verdrahtung und Breadboard: Zum Verbinden aller Komponenten.
Taster : Programm Reset Button

Systemkonzept

Das Arduino ist so programmiert, dass es die Eingaben von drei Sensoren überwacht. Jeder Sensor bietet Feedback über das LCD-Display:

Lichtsensor: Zeigt an, wenn eine bestimmte Lichtintensität erkannt wird.
Temperatursensor: Zeigt an, wenn Wärme erkannt wird (z.B. durch menschliche Berührung).
Distanzsensor: Zeigt an, wenn ein Objekt innerhalb eines bestimmten Bereichs erkannt wird (z.B. eine sich bewegende Hand).
Sobald alle drei Sensoren aktiviert sind, wird eine endgültige Nachricht auf dem LCD angezeigt, die bestätigt, dass das Rätsel gelöst wurde.

Rätsel

ich habe drei Augen: eins sieht Licht, eins spürt Wärme, und eins erkennt Bewegung. Aktiviere alle, und mein Geheimnis wird enthüllt.

Anforderungen

Funktionaler Systementwurf/Technischer Systementwurf

Eingaben: 

        • Lichtsensor 
        • Temperatursensor 
        • Ultraschallsensor

Verarbeitung: 

        • Arduino überwacht die Sensoreingaben. 
        • Abhängig vom Zustand der Sensoren werden spezifische Nachrichten auf dem LCD angezeigt.

Ausgabe: 

       • 16x2 LCD-Display zeigt Feedback
       • Licht erkannt 
       • Wärme erkannt 
       • Objekt erkannt 
       • Wenn alle Sensoren aktiviert sind, wird die finale Nachricht angezeigt.


Tabelle 1: Anforderungen
Nr Anforderung Autoren Datum
1 Das Arduino muss die Eingaben der drei Sensoren (Lichtsensor, Temperatursensor, Distanzsensor) korrekt überwachen. Maha Chraiji, Oluwatobiloba Oguntona 14.10.2024
2 Jeder Sensor muss durch eine spezifische Aktion aktiviert werden können. Maha Chraiji, Oluwatobiloba Oguntona 14.10.2024
3 Das 16x2 LCD-Display muss die Sensoreingaben wie folgt anzeigen. Maha Chraiji, Oluwatobiloba Oguntona 14.10.2024
4 Sobald alle drei Sensoren aktiviert sind, muss das LCD die Lösung des Rätsels anzeigen: "Guardian's Secret Revealed!" Maha Chraiji, Oluwatobiloba Oguntona 18.10.2024
5 Arduino, Taster, Lichtsensor, Temperatursensor, Distanzsensor, 16x2 LCD-Display, Breadboard, Verkabelung. Maha Chraiji, Oluwatobiloba Oguntona 18.10.2024
6 Code in der Arduino IDE schreiben, Sensoreingaben verarbeiten, Ausgabe auf LCD-Display anzeigen. Maha Chraiji, Oluwatobiloba Oguntona 30.10.2024
7 Das Rätsel und die Anweisungen müssen klar und einfach formuliert sein. Maha Chraiji, Oluwatobiloba Oguntona 05.11.2024
8 Optisch ansprechender Aufbau (saubere Verkabelung, gut lesbare Anzeige). Maha Chraiji, Oluwatobiloba Oguntona 05.11.2024
9 Jeder Sensor wird einzeln getestet (Licht, Wärme, Bewegung). Maha Chraiji, Oluwatobiloba Oguntona 05.11.2024
10 Überprüfung der korrekten Systemreaktion, wenn alle drei Sensoren aktiviert werden. Maha Chraiji, Oluwatobiloba Oguntona 07.11.2024
11 Schaltplan und Aufbauanleitung für das Projekt. Maha Chraiji, Oluwatobiloba Oguntona 07.11.2024
12 Arduino-Code mit Kommentaren. Maha Chraiji, Oluwatobiloba Oguntona 20.12.2024
13 Ein Taster muss implementiert sein, um das Programm zurückzusetzen und alle Sensorzustände zu löschen. Maha Chraiji, Oluwatobiloba Oguntona 05.01.2025
Tabelle 2: Materialliste
Nr. Anz. Beschreibung
1 1 Arduino Uno
2 1 LCD Display
3 1 Ultraschall Abstandsensor
4 1 TMP36
5 1 Lichtsensor/Fotowiderstand
6 1 Taster
7 1 RGB LED
Abb. 01: PAP Design
Abb. 02: Schaltplan Arduino
Abb. 03: CAD Model Oberseite
Abb. 04: CAD Model Unterseite































Komponentenspezifikation

Umsetzung (HW/SW)

Abb.05: Setup Build
Video: Implementierung der Sensoren









Hier ist der Code, der die Grundlage unseres Projekts bildet: 

/*****************************************************************************
Autoren:   Maha Chraiji, Oluwatobiloba Oguntona                              *
Programm:  Sensoren-Puzzle mit Arduino                                       *
Modul:     Fachpraktikum Elektrotechnik                                      *
Betreuer:  Professor Göbel                                                   *
Semester:  Wintersemester 2024/2025                                          *
*****************************************************************************/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// Initialize I2C LCD (use the detected address, usually 0x27 or 0x3F)
LiquidCrystal_I2C lcd(0x27, 16, 2); // Address, columns, rows

// Pin definitions for sensors
const int lightSensorPin = A0;
const int tempSensorPin = A1;
const int distanceTriggerPin = 3;
const int distanceEchoPin = 2;

// RGB LED pins
const int rgbRedPin = 6;
const int rgbGreenPin = 5;
const int rgbBluePin = 4;

// Reset button pin
const int resetButtonPin = 7;

// Target values and tolerances
const int targetLight = 0; // As dark as a room can get
const int lightTolerance = 5;
const float targetTemp = 24.0; // Average finger tip temperature
const float tempTolerance = 2.0;
const float targetDistance = 8.0;
const float distanceTolerance = 1.0;

// Task completion flags
bool tasksCompleted[3] = {false, false, false};

void setup() {
  // Initialize LCD
  lcd.init();        // Initialize the LCD
  lcd.backlight();   // Turn on the LCD backlight

  // Initialize RGB LED pins
  pinMode(rgbRedPin, OUTPUT);
  pinMode(rgbGreenPin, OUTPUT);
  pinMode(rgbBluePin, OUTPUT);

  // Initialize distance sensor pins
  pinMode(distanceTriggerPin, OUTPUT);
  pinMode(distanceEchoPin, INPUT);

  // Initialize reset button pin
  pinMode(resetButtonPin, INPUT_PULLUP);

  // Start message
  lcd.print("Awaken the");
  lcd.setCursor(0, 1);
  lcd.print("Guardian...");
  delay(5000);
  lcd.clear();
}

void loop() {
  // Ensure tasks run only if they are incomplete
  if (!tasksCompleted[0] && checkLightSensor()) {
    tasksCompleted[0] = true;
    lcd.clear();
    lcd.print("Eye of Light");
    lcd.setCursor(0, 1);
    lcd.print("Activated!");
    activateRGB(255, 255, 255); // White light
    delay(5000);
    deactivateRGB();
  } else if (!tasksCompleted[0]) {
    lcd.clear();
    lcd.print("Light incorrect");
    lcd.setCursor(0, 1);
    lcd.print("Adjust light!");
    delay(1000);
  }

  if (!tasksCompleted[1] && checkTempSensor()) {
    tasksCompleted[1] = true;
    lcd.clear();
    lcd.print("Eye of Fire");
    lcd.setCursor(0, 1);
    lcd.print("Activated!");
    activateRGB(255, 0, 0); // Red light
    delay(5000);
    deactivateRGB();
  } else if (!tasksCompleted[1]) {
    lcd.clear();
    lcd.print("Temp incorrect");
    lcd.setCursor(0, 1);
    lcd.print("Adjust temp!");
    delay(1000);
  }

  if (!tasksCompleted[2] && checkDistanceSensor()) {
    tasksCompleted[2] = true;
    lcd.clear();
    lcd.print("Eye of Space");
    lcd.setCursor(0, 1);
    lcd.print("Activated!");
    activateRGB(0, 0, 255); // Blue light
    delay(5000);
    deactivateRGB();
  } else if (!tasksCompleted[2]) {
    lcd.clear();
    lcd.print("Distance wrong");
    lcd.setCursor(0, 1);
    lcd.print("Adjust pos!");
    delay(1000);
  }

  // Check if all tasks are completed
  if (tasksCompleted[0] && tasksCompleted[1] && tasksCompleted[2]) {
    lcd.clear();
    lcd.print("Guardian's");
    lcd.setCursor(0, 1);
    lcd.print("Secret Revealed!");
    victorySequence();
    delay(10000);

    // Wait for reset button to be pressed
    while (true) {
      if (digitalRead(resetButtonPin) == HIGH) {
        resetSystem();
        break;
      }
    }
  }
}

// Light sensor check
bool checkLightSensor() {
  int lightValue = analogRead(lightSensorPin);
  return abs(lightValue - targetLight) <= lightTolerance;
}

// Temperature sensor check
bool checkTempSensor() {
  int tempValue = analogRead(tempSensorPin);
  float voltage = tempValue * 5.0 / 1023.0;
  float tempC = (voltage - 0.5) * 100;
  return abs(tempC - targetTemp) <= tempTolerance;
}

// Distance sensor check
bool checkDistanceSensor() {
  digitalWrite(distanceTriggerPin, LOW);
  delayMicroseconds(2);
  digitalWrite(distanceTriggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(distanceTriggerPin, LOW);

  long duration = pulseIn(distanceEchoPin, HIGH);
  float distance = duration * 0.034 / 2; // Convert to cm
  return abs(distance - targetDistance) <= distanceTolerance;
}

// RGB LED control
void activateRGB(int red, int green, int blue) {
  analogWrite(rgbRedPin, red);
  analogWrite(rgbGreenPin, green);
  analogWrite(rgbBluePin, blue);
}

void deactivateRGB() {
  analogWrite(rgbRedPin, 0);
  analogWrite(rgbGreenPin, 0);
  analogWrite(rgbBluePin, 0);
}

// Victory sequence for RGB LED
void victorySequence() {
  for (int i = 0; i < 3; i++) {
    activateRGB(0, 255, 0); // Green light
    delay(500);
    deactivateRGB();
    delay(500);
  }
}

// Reset system to initial state
void resetSystem() {
  // Reset task completion flags
  for (int i = 0; i < 3; i++) {
    tasksCompleted[i] = false;
  }

  // Clear LCD and show start message
  lcd.clear();
  lcd.print("Awaken the");
  lcd.setCursor(0, 1);
  lcd.print("Guardian...");
  delay(5000);
  lcd.clear();

  // Deactivate RGB LED
  deactivateRGB();
}









Komponententest

Ergebnis

Schritte, um das Rätsel zu lösen
1. Lichtsensor aktivieren

  • Bedecken Sie den Lichtsensor (z. B. mit Ihrer Hand/einem Deckel), um die Lichtintensität zu verringern.
  • Sobald der Lichtsensor korrekt aktiviert wird:
  • Die weiße LED beginnt zu blinken.
  • Eine Rückmeldung erscheint auf dem LCD (z. B. „Eye of Light Activated “).

2. Temperatursensor aktivieren

  • Erhöhe die Temperatur des Temperatursensors, z. B. durch Berühren mit der Hand.
  • Sobald der Temperatursensor korrekt aktiviert wird:
  • Die rote LED beginnt zu blinken.
  • Eine Rückmeldung erscheint auf dem LCD (z. B. „Eye of Fire Activated“).

3. Distanzsensor aktivieren

  • Bewege deine Hand oder ein Objekt in die Nähe des Distanzsensors.
  • Sobald der Distanzsensor korrekt aktiviert wird:
  • Die blaue LED beginnt zu blinken.
  • Eine Rückmeldung erscheint auf dem LCD (z. B. „Eye of Space Activated“).

4. Rätsellösung anzeigen

  • Wenn alle drei Sensoren korrekt aktiviert, wurden:
  • Die grüne LED blinkt dreimal, um den Erfolg anzuzeigen.
  • Die finale Lösung des Rätsels erscheint auf dem LCD (z. B. „Guardian’s Secret Revealed!“).

5. System zurücksetzen

  • Drücke den Taster, um das System zurückzusetzen.
  • Alle LEDs schalten sich aus, und das LCD zeigt wieder die Startmeldung an.

Zusammenfassung

Lessons Learned

Projektunterlagen

Projektplan

Projektplan Analyse und Konzeptphase
1. Zieldefinition

  • Ziel: Interaktive Steuerung basierend auf Sensoren zur Lösung eines Rätsels.
  • Anforderungen: Arduino, Sensoren (Licht, Temperatur, Distanz), LEDs, Taster, LCD-Display, Platine, Zubehör.



2. Systemdesign

  • Schaltplan erstellen (Verbindung der Sensoren mit dem Arduino, den LEDs, dem Taster und dem LCD).
  • Definition der Logik für das Rätsel:
  • Sensor-Trigger → LED-Aktivierung in spezifischen Farben (weiß, rot, blau).
  • LED blinkt grün dreimal, wenn alle Sensoren korrekt aktiviert wurden.
  • Taster-Logik zur Rücksetzung des Systems nach jeder Verwendung.



Hardware-Setup
3. Beschaffung der Komponenten

  • Einkauf der benötigten Hardware (Arduino, Sensoren, LEDs, LCD, Taster, Platine, Zubehör).



4. Aufbau des Prototyps

  • Erste Verkabelung der Komponenten auf einem Breadboard gemäß Schaltplan.
  • Testphase zur Überprüfung der Hardwarefunktionalität und Logik.



Softwareentwicklung
5. Programmierung des Arduino

  • Code schreiben für die Integration der Sensoren, LEDs, des Taster-Resets und des LCD-Displays.
  • Implementierung der Logik:
  • Lichtsensor: Aktiviert weiße LED, wenn korrekt erkannt.
  • Temperatursensor: Aktiviert rote LED, wenn korrekt erkannt.
  • Distanzsensor: Aktiviert blaue LED, wenn korrekt erkannt.
  • Alle LEDs deaktivieren sich nach Reset durch den Taster.
  • Grüne LED blinkt dreimal, wenn alle Sensoren korrekt aktiviert wurden.
  • Test: Jeder Sensor zeigt die korrekte LED-Farbe und Rückmeldung auf dem LCD an.



6. Integration des Rätsels

  • Hinzufügen der finalen Logik:
  • LEDs und LCD geben Feedback bei jedem Sensor-Trigger.
  • LCD zeigt die Lösung nur, wenn alle Sensoren korrekt aktiviert sind.
  • Grüne LED blinkt dreimal, um das erfolgreiche Lösen des Rätsels zu signalisieren.
  • System kann mit dem Taster zurückgesetzt werden.


Optimierung und endgültiger Aufbau
7. Systemtests

  • Einzeltests für jeden Sensor (korrekte LED und LCD-Rückmeldung).
  • Gesamttest: Rätsel vollständig aktivieren, um die Endnachricht und das grüne Blinken zu prüfen.
  • Funktionalität des Tasters: System wird erfolgreich zurückgesetzt.


8. Endgültiger Aufbau auf Platine

  • Übertragen der Schaltung von einem Breadboard auf eine Platine.
  • Die Platine wird so gestaltet, dass sie direkt auf den Arduino-Mikrocontroller gesteckt werden kann (Shield).
  • Finaler Test der gesamten Schaltung mit der Platine.
Abb. 01: Zeitplan Arduino Puzzle









Projektdurchführung

YouTube Video

Weblinks

Literatur

→ zurück zur Übersicht: WS 23/24: Angewandte Elektrotechnik (BSE)

Abgerufen von „https://wiki.hshl.de/wiki/index.php?title=Sensoren-Puzzle_mit_Arduino&oldid=131644“