SmartFarm: Unterschied zwischen den Versionen
Zeile 516: | Zeile 516: | ||
In dieser ist festgelegt worden, an welche Pins welche Bauteile angeschlossen sind. | In dieser ist festgelegt worden, an welche Pins welche Bauteile angeschlossen sind. | ||
<div style="width:820px; height: | <div style="width:820px; height:820px; overflow:auto; border: 1px solid #000"> | ||
<pre> | <pre> | ||
#ifndef Parameter_h | #ifndef Parameter_h |
Version vom 9. Februar 2021, 17:44 Uhr
Autoren: Isaac Mpidi Bita, Dominik Hermelingmeier
Betreuer: Prof. Göbel
→ zurück zur Übersicht: WS 20/21: Angewandte Elektrotechnik (BSE)
Einleitung
Diese Arbeit wurde im Rahme der Veranstaltung "Angewandte Elektronik" im Masterstudiengang "Business and Systems Engineering" (BSE/BaSE) angefertigt. Es werden folgende Ziele verfolgt:
- Auswertung von Sensorinformationen
- Ansteuerung von verschiedenen Sensoren und Aktuatoren
- Verarbeitung von Signalen im Rahmen der Mess- und Regelungstechnik mit einem Microcontroller
Die Veranstaltung wird mit einem mechatronischen Projekt begleitet, welches die folgenden Phasen beinhaltet:
- Projektplanung und Schaltungsentwurf
- Beschaffung der Bauteile und Materialien
- Entwicklung (z. B. Platinenlayout) und Fertigung mit anschließender Inbetriebnahme
- Projektdemonstration, -abnahme und -dokumentation
Heutzutage spielt das Konzept "SMART" eine wichtige Rolle in zahlreichen alltäglichen Bereichen. In der Landwirtschaft gewinnt der Einsatz moderner Techniken, genauer gesagt Informations- und Kommunikationssysteme, immer mehr an Bedeutung. Diese Revolution wird in dem Bereich als "Landwirtschaft 4.0" bezeichnet. Im Rahmen des Moduls "Angewandte Elektrotechnik" ist das Projekt SmartFarm entstanden.
Das Projekt "SmartFarm" verfolgt das Ziel, mit Sensorsystemen und Aktuatoren die Tierhaltung im Einklang mit den Tieren zu erleichtern und zu optimieren. Der Fokus liegt auf der einer Tür- und Helligkeitssteuerung in einem Hühnerstall. Zudem besteht die Möglichkeit, sowohl die Tür als auch die Lampe manuell anzusteuern. Das Projekt "SmartFarm" bietet viele weitere Erweiterungsmöglichkeiten, die im Ausblick eingegangen wird.
Ein geschlossener Stall schützt die Hühner über Nacht vor Raubtieren. Die Türsteuerung verschafft dem Tierhalter Unabhängigkeit und Flexibilität beim Öffnen und Schließen der Tür. Aus der Lampensteuerung resultiert eine erhöhte Legeleistung in der dunklen Jahreszeit durch einen künstlich verlängerten Tag.
V-Modell als Vorgehensmodell
Das V-Modell ist ein Prozessmodell zur Systementwicklung. Dieses Modell wird für die Entwicklung des linearen Einspurmodells verwendet und gliedert sich schwerpunktmäßig in die Entwurfsphase, Implementierung und Testphase. Das Ergebnis bzw. Ziel ist ein fertiges Produkt (s. Abbildung 1). Das V-Modell wird für die Entwicklung aus den folgenden Gründe ausgewählt [2]:
- Klare Projektstruktur mit Qualitätsgewährleistung
- bessere Planbarkeit durch fest vorgegebene Rollen, Strukturen und Ergebnisse
- Verbesserung der Kommunikation zwischen den Beteiligten
- Zusammenspiel von Konzipierung und Qualitätssicherung
- Verbesserung der Projektdokumentation
Die Meilensteine dieses Projektes sind gemäß der Prozessschritte im V-Modell definiert und lauten:
- Anforderungsdefinition
- Funktionaler Entwurf
- Technischer Systementwurf
- Komponentenspezifikation
- Programmierung
- Komponententest/Unittest
- Integrationstest/ Modultest
- Systemtest
- Abnahmetest
Anforderungsmanement
Allgemeine Projektanforderungen
- Entwurf eines mechatronischen Systems für die Helligkeit- und Türsteuerung eines Hühnerstalls
- Erfassung der Helligkeit bzw. der Zeit für die Öffnung der Tür
- Erfassung der Helligkeit bzw. der Zeit für die Helligkeitsteuerung
- Erarbeiten einer alternativen Lösung für die manuelle Türsteuerung (unabhängig von der Helligkeit)
- Vorstellung und Erarbeiten eines Konzepts für eine geregelte Bewegung der Tür
- Erarbeitung einer Energieversorgungssystem für das System
- Softwareentwicklung nach HSHL Standard in SVN
Lastenheft
Detaillierte Anforderung werden in einer Lastenheft in Form eines Excel-Tabelle zusammengefasst. Diese gliedert sich in die folgenden Punkten entsprechend SysML-Standard:
- Projektziel
- Functional Requirements
- Physical Requirements
- Usability Requirements
- Business Requirements
- Performance Requirements
- Non-functional Requirements
- Extended Requirements
- Meilensteinen
ID | Typ (I = Info, A = Anforderung) | Kapitel | Inhalt | Ersteller | Datum |
---|---|---|---|---|---|
REQ-000 | I | 0 | Projektziel | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-001 | A | 0.1 | Mit Sensorsystemen und Aktuatoren die Tierhaltung im Einklang mit den Tieren erleichtern und optimieren. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-100 | I | 1 | Functional Requirements | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-110 | A | 1.1 | Ein mechatronisches System für die Helligkeit- und die Türsteuerung muss entworfen werden. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-140 | A | 1.3 | Der Zustand der Tür und der Lampe müssen nur an bestimmsten Zeiten im Automatik-Betrieb geändert werden. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-150 | A | 1.4 | Die Tür muss bei ausreichende Außenhelligkeit aufgehen, andersfalls muss es zu sein. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-200 | I | 2 | Physical Requirements | I. Mpidi Bita & D. Hermelingmeier | 02.05.2020 |
REQ-210 | A | 2.1 | Ein Gehäusekonzept muss erarbeitet werden. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-210 | A | 2.2 | Der ausgewählte Motor muss die Tür heben können. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-230 | A | 2.3 | Die Masse der Tür muss auf keinen Fall ein Wert von 5 Kg überschreiten. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-240 | A | 2.4 | Die Länge des Seils muss eine komplette Öffnung bzw. Schließung der Tür ermöglichen | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-250 | A | 2.5 | Die Zugfestigkeit des Seils muss dem Heben und Senken der Holztür standhalten. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-300 | I | 3 | Usability Requirements | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-310 | A | 3.1 | Eine alternative Lösung zur manuelle Ansteuerung muss angeboten werden. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-311 | A | 3.1 | Es muss eine Möglichkeit bestehen, jeder Zeit die Tür zu öffnen bzw. zu schließen. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-312 | A | 3.2 | Es muss eine Möglichkeit bestehen, jeder Zeit die Beleuchtung an- bzw. auszuschalten. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020
|
REQ-400 | I | 4 | Business Requirements | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-500 | I | 5 | Performance Requirement | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-520 | A | 5.2 | Der Motor darf sich maximal mit einer Geschwindigkeit von 9 RPM drehen. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-600 | I | 6 | Non functional Requirement | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-610 | A | 6.1 | Toolanforderungen | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-611 | A | 6.1.1 | Das Projekt geht bei der Entwicklung nach dem V-Modell vor. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-613 | A | 6.1.3 | Als Versionsverwaltungstool wird SVN oder Git eingesetzt. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-620 | A | 6.2 | Qualitätsicherung | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-620 | A | 6.2 | Sowohl für die implementierte Software als auch für die Modelle müssen
geeignete Tests erstellt werden:
|
I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-700 | I | 7 | Extended Requirement | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-720 | A | 7.2 | Die echte Uhrzeit muss für den Ansteuerung erfasst werden. | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-800 | I | 7 | Meilensteine | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
REQ-810 | A | 8.1 | Erstellung des Lastenhefts | I. Mpidi Bita & D. Hermelingmeier | 05.05.2020 |
044 | A | 4.2 | Funktionaler und technischer Systemplan | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
045 | A | 4.3 | Komponentenspezifikationen | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
046 | A | 4.4 | Simulink/Modell und MATLAB-Parameterdatei und C++-Code | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
047 | A | 4.5 | Komponentetest in der Form eines Unittestberichts | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
048 | A | 4.6 | Integrationstest in der Form eines Modultestberichts | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
049 | A | 4.7 | Systemtest in der Form eines Systemtestberichts | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
049 | A | 4.7 | Abnahmetest in der Form eines Wiki-Artikels | I. Mpidi Bita & D. Hermelingmeier | 20.10.2020 |
Tab.1: Auszug aus dem Lastenheft
Funktionaler Systementwurf
Der funktionale Systementwurf beinhaltet drei wesentliche Abschnitte:
- FE-Gesamtsystem
- Softwarearchitektur
- Hardwarearchitektur
Aus diese Entwürfe wird eine BOM bzw. Stückliste der Bauteile ermittelt für die Realisierung des Projektes.
Gesamtsystem
Wie in Abbildung 2 zu sehen ist, besteht das Projekt "SmartFarm" aus mehreren Gegenständen. Bei diesem Entwurf ist das Ziel das System in der Funktionalität abzugrenzen und
Rahmen für das Uni-Projekt aufzustellen. Für das Uni-Projekt besteht das Stall-System aus zwei Subsystem bzw. Teilsysteme. Diese sind die Helligkeits- und die Türsteuerung wie
in der unteren Abbildung zu sehen ist.
Bei der Helligkeitssteuerung wird eine Lampe dafür sorgen, dass es im Stahl bei Dunkelheit durch nicht Scheinen der Sonnen hell genug ist, damit die Hühner sich frei bewegen
können. Wessentliche Anforderungen der Helligkeitssteuerung ist unter REQ-140. Das zweite Subsystem ist die Türsteuerung. Hier soll die Tür automatisch entsprechend REQ-110,
REQ-230, REQ-240, REQ-250 und REQ-520 hoch und runterfahren. Beide Systeme sind sowohl Zeit- als auch Außenhelligkeit abhängig.
Softwarearchitektur
Im Folgende wird die Softwarearchitektur des obengenannten Systems beschrieben. Die Software spielt bei Embedded-Systeme eine wesentliche Rolle. Das Ziel hierbei ist die klare
funktionsbasierte Abgrenzung von verschiedenen Softwarekomponenten. Aufgrund der höchstwahrscheinliche Änderung der Software ist es wichtig, dass die Architektur von dieser
Anforderungen wie die Skalierbarkeit, Performanz und Anpassbarkeit erfühlen. Diese Anforderungen werden durch Einsatz von Objekt orientierte Programmierung.
Die Softwarearchitektur besteht aus folgende Elemente:
- Main-Funktion
- Signalaufbereitung: Schnittstelle zwischen Sensoren und Software
- Aktuatorausgabe : Schnittstelle zwischen Software und Aktuatoren
- Türsteuerung
- Helligkeitssteuerung
Die Klasse-Signalaufbereitung beschäftigt sich mit der Sensoren das System. Hier werden die verschiedene Sensoren beim Systemstart initialisiert. Während des Systembetriebs
werden alle Sensorsignale aufgenommen und zur Verfügung gestellt. Im Klasse-Aktuatorausgabe leitet die Befehle an den Aktuatoren weiter. Die eigentliche Automatisierungs-
funktionen werden in der jeweiligen Klasse Tür- und Helligkeitssteuerung. Die Main-Funktion ist das Herzstück des Programms. Hier wird der Programmabfluss durch verweise
und Funktionsaufruf gesteuert.
Hardwarearchitektur
Eingabe bzw. Sensoren:
- LDR : Helligkeitsaufnahme
- Touch-Sensor: Manuelle Ansteuerung der Tür und der Lampe
- Ultraschallsensor: Erfassung der Türposition
- Kippschalter: Betriebmoduswechsel
- RTC-Sensor: Gibt die echte Uhrzeit an
Mikrocontroller: Systemsteuereinheit
Ausgabe bzw. Aktuatoren:
- UV-Lampe: erzeugt künstliches Tageslicht im Stall
- Motor: öffnet oder schließt die Tür
Stückliste
Technischer Systementwurf
Im technischen Systementwurf wird der Systemplan entworfen. Dabei werden die Komponenten und Schnittstellen in den einzelnen Modulen festgelegt.
TE-Software
TE-Hardware
Software-Hardware-Schnittstelle
Die Hardware-Software-Schnittstellen sind die Module Sensor-Signalaufbereitung und Aktuatorenausgabe. Damit die Software das richtige Element steuert, wird eine sogenannte Parameter-Datei erstellt.
In dieser ist festgelegt worden, an welche Pins welche Bauteile angeschlossen sind.
#ifndef Parameter_h #define Parameter_h #include "Arduino.h" // **************************************************************** // H-Brige // **************************************************************** #define _HBRIDGE_PWM_ENA_PIN_ 10 #define _HBRIDGE_DIG_IN1_PIN_ 9 #define _HBRIDGE_DIG_IN2_PIN_ 8 // ***************************************************************** // Ultraschall-Sensor // ***************************************************************** #define _US_DIG_TRIG_PIN_ 7 #define _US_DIG_ECHO_PIN_ 6 // ***************************************************************** // Touch-Sensoren // ***************************************************************** #define _TOUCH_DIG_TUER_PIN_ 3 #define _TOUCH_DIG_LAMPE_PIN_ 4 // ***************************************************************** // Fotowiderstand // ***************************************************************** #define _FOTOWIDERSTAND_ANA_PIN_ A0 // ***************************************************************** // Kippschalter // ***************************************************************** #define _KIPPSCHALTER_DIG_TUER_PIN_ 12 #define _KIPPSCHALTER_DIG_LAMPE_PIN_ 13 // ***************************************************************** // Relais // ***************************************************************** #define _RELAIS_DIG_LAMPE_PIN_ 5 // ***************************************************************** // Real-Time-Clock-Sensor // ***************************************************************** // #define _RTC_ANA_SDA_PIN_ A4 // #define _RTC_ANA_SCL_PIN_ A5 #endif
Komponentenspezifikation
Bei der Komponentenspezifikation werden die Aufgaben und das Verhalten jeder Komponenten definiert. Darüber hinaus wird der innere Aufbau mit den Schnittstelle jeder Komponente festgestellt.
Diese unterteilrt sich in der Software und Hardwarespezifiketionen auf.
Softwarespezifikationen
Betriebsmodis - Stallsystem
Tageslichtabfrage mit Hysterese
Spezifikation der Türsteuerung
Türstatus - Manuell-Betrieb
Türstatus - Automatikbetrieb
Zeiterfassung für die Türsteuerung
Spezifikation der Lampensteuerung
Lampenstatus - Manuell-Betrieb
Lampenstatus - Automatikbetrieb
Zeiterfassung für die Helligkeitssteuerung
Hardwarespezifikationen
Implementierung
Programmablaufplan
Türsteuerung im Automatik-Betrieb
Helligkeitssteuerung im Automatik-Betrieb
Modellierung und Simulation des Stall-Systems in MATLAB-Simulink
Implementierung des Stall-Systems in C/C++
Bibliotheken-Einbindung und Variablen definition
// ******************************************************************************************** // Bibliotheken einbinden // ******************************************************************************************** #include "Parameter.h" #include "Sensor_Signalaufbereitung.h" #include "Tuersteuerung.h" #include "Helligkeitssteuerung.h" #include "Aktuator_Signalausgabe.h" #include "Wire.h" // ******************************************************************************************** // Variablen Definition // ******************************************************************************************** hSENSOR_SIGNAL SenSig; hAKTUATOR_AUSGABE AktSig; hHELLIGKEITSSTEUERUNG Helligkeitssteuerung; hTUERSTEUERUNG Tuersteuerung;
Main-Funktion
//********************************************************************************************* // SETUP-Funktion: // the setup function runs once when you press reset or power the board //********************************************************************************************* void setup(){ Serial.begin(9600); Wire.begin(); } //********************************************************************************************* // LOOP-Funktion: // the loop function runs over and over again forever //********************************************************************************************* void loop(){ // ************************************************************* // Start - Helligkeitssteuerung Helligkeitssteuerung.StartHS(SenSig, AktSig); // ************************************************************* // ************************************************************* // Start - Helligkeitssteuerung Tuersteuerung.StartTS(SenSig, AktSig); // ************************************************************* Serial.println(' '); }
Türsteuerung
class hTUERSTEUERUNG { private: // ************************************************************ // Zeiterfassung für die Türsteuerung (State Machine) // ************************************************************ bool stmZeitErfassungTuer(unsigned int nStunden); // ************************************************************ // Entscheidung Türbewegung im Automatik-Betrieb // ************************************************************************ int Entscheidung_Tuerbewegung_Automatik(bool bTuerFlag, bool bHelligkeitszustand); // ************************************************************************ // Türsteuerung Manuellen und Automatik-Betrieb (State Machine) // ************************************************************************ int TuerBetrieb(bool bTuerBewegungAuto, bool bTouchTuer, int nAbstand, bool bKippschalter); // ************************************************************************ public: hTUERSTEUERUNG(); // ************************************************************************ // Abfrage Türzustand // ************************************************************************ int getTuerZustand(); // ************************************************************************ // Abfrage Betrieb // ************************************************************************ // bool getTuerBetrieb(); // ************************************************************************ // Start-Funktion // ************************************************************************ void StartTS(hSENSOR_SIGNAL &SenSig, hAKTUATOR_AUSGABE &AktSig); // ************************************************************************ };
Helligkeitssteurung
class hHELLIGKEITSSTEUERUNG{ private: // ************************************************************ // Zeiterfassung für die Helligkeitssteuerung (State Machine) // ************************************************************ bool stmZeitErfassungLampe(int nStunden); // ************************************************************ // Entscheidung Lampenzustand im Automatik-Betrieb // ************************************************************ int Entscheidung_Lampenbewegung_Automatik(bool bLampenFlag, bool bHellZustand); // ************************************************************************ // Helligkeitssteuerung Manuellen und Automatik-Betrieb (State Machine) // ************************************************************************ bool LampenBetrieb(bool bLampeZustandAuto, bool bTouch_Lampe, bool bKippschalterHelligkeit); // ************************************************************************ // ************************************************************************* // Initialisierung der Lampensteuerung // ************************************************************************* public: hHELLIGKEITSSTEUERUNG(); // ************************************************************************ // Abfrage Lampenzustand // ************************************************************************ bool getTuerZustand(); // ************************************************************************ // Start-Funktion // ************************************************************************ void StartHS(hSENSOR_SIGNAL& SenSig, hAKTUATOR_AUSGABE& AktSig); // ************************************************************************ };
Sensor-Signalaufbereitung
class hSENSOR_SIGNAL{ private: // ************************************************************ // Ultraschall-Sensor // ************************************************************ long Berechnung_Entfernung(); // ************************************************************ // Zeitsensor // ************************************************************ int leseZeitvomRTC(); public: // ************************************************************ // Initialisierung alle Sensoren // ************************************************************ hSENSOR_SIGNAL(){ // Touch-Sensor pinMode(_TOUCH_DIG_TUER_PIN_, INPUT); pinMode(_TOUCH_DIG_LAMPE_PIN_, INPUT); // Ultraschall pinMode(_US_DIG_ECHO_PIN_, INPUT); pinMode(_US_DIG_TRIG_PIN_, OUTPUT); // Fotowiderstand pinMode(_FOTOWIDERSTAND_ANA_PIN_, INPUT); nSchwellwert = 300; nOffset = 50; StateHelligkeit = S1_DUNKEL; bHelligkeitszustand = 0; // Kippschalter //pinMode(_TOUCH_DIG_TUER_PIN_, INPUT); }; // ************************************************************ // *********************************************************** // Abfrage der Sensoren // *********************************************************** // Touch-Sensoren // *********************************************************** bool getTouchTuer(); bool getTouchLampe(); // *********************************************************** // Ultraschallsensor // *********************************************************** long getAbstand(); // *********************************************************** // Fotowiderstand // *********************************************************** unsigned int getHeligkeitRoh(); bool getHelligkeit(); // *********************************************************** // Real-Time-Sensor // *********************************************************** unsigned int getZeitStunden(); // ************************************************************ // Kippschalter // *********************************************************** bool getKippschalterTuer(); bool getKippschalterLampe(); // ************************************************************ };
Aktuator-Signalausgabe
class hAKTUATOR_AUSGABE{ public: // ************************************************************ // Initialisierung der Aktuatoren // ************************************************************ hAKTUATOR_AUSGABE(){ pinMode(_RELAIS_DIG_LAMPE_PIN_, OUTPUT); pinMode(_HBRIDGE_DIG_IN1_PIN_, OUTPUT); pinMode(_HBRIDGE_DIG_IN2_PIN_, OUTPUT); pinMode(_HBRIDGE_PWM_ENA_PIN_, OUTPUT); }; // ************************************************************ // Signalausgabe zu den Aktuatoren // ************************************************************ // UV-Lampe // ************************************************************ bool getUVLampeZustand(); void setUVLampeZustand(bool LampenZustand); // ************************************************************ // Stall Tür // ************************************************************ int getTuerZustand(); void setTuerZustand(bool bMotorZustand, bool bMotorRichtung); // ************************************************************ };
Testphase
Komponententest
Testfall-ID | Testfall-Name | Anforderungs-ID | Vorbedingungen und Eingänge | Aktionen | Erwartetes Ergebnis | Ergebnis | Bewertung | Kommentar |
---|---|---|---|---|---|---|---|---|
KT-HW-001 | RTC - Erfassung der echten Uhrzeit | REQ-141, REQ-142, REQ-720, KS-RTC-000 | I2C-Bus verbunden | Messwert lesen | 17 Uhr | 17 Uhr | i. O. | |
KT-HW-002 | LDR - Aufnahme des Tageslicht um 12 Uhr mittag | REQ-111, REQ-112, KS-LDR-000 | Richtige Aufstellung und Berechnung der Spannungsteilergleichung | Messwert auslesen | Hohe Analogsignal nah an 1023 | Hohe Analogsignal nah an 1023 | i. O. | |
KT-HW-003 | LDR - Aufnahme des Tageslicht um 4 Uhr morgen | REQ-111, REQ-112, REQ-150, KS-LDR-000 | Richtige Aufstellung und Berechnung der Spannungsteilergleichung | Messwert auslesen | Niedriege Analogsignal nah an die Null | Niedriege Analogsignal nah an die Null | i. O. | |
KT-HW-004 | US-Sensor - Distanzmessung in cm | KS-US-000 | Richtige Berechnung der Laufzeit | Messwert auslesen | 10 cm | 10 cm | i. O. | |
KT-HW-007 | Motor - Öffnen und Schließen einer 5 kg Tür über eine Seilwinde | REQ-001, REQ-230, REQ-250, REQ-520 | Seil über die Umlenkrolle richtig einrolle | PWM-Signal über H-Bridge schicken | Hochheben und Sinken der Tür je 1 sec. | Hochheben und Sinken der Tür je 1 sec. | i. O. |
Tab. 4: Ausschnitt aus Komponententest der Hardwarekomponente
Integrationstest
Betriebsmoduswechsel-Test - Lampensteuerung
using namespace std; int ZustandLampenbetrieb = S2_AUTOMATIK_BETRIEB_HELLIGKEIT; int ZustandLampeManuelinnen = S0_NEUTRAL; bool bLampenStatus = 0; int ZustandLampeAutomatikinnen = S0_NEUTRAL; bool LampenBetrieb(bool bLampeZustandAuto, bool bTouch_Lampe, bool bKippschalterHelligkeit); int main() { int touch = 0; int entscheidung; for (int i = 1; i < 10; i++) { cin >> entscheidung; LampenBetrieb(entscheidung, touch, 1); } //LampenBetrieb(0, 0, 1); LampenBetrieb(0, 0, 0); // LampenBetrieb(0, 0, 1); LampenBetrieb(0, 0, 0); system("pause"); return 0; }
Testfall-ID | Testfall-Name | Anforderungs-ID | Vorbedingungen und Eingänge | Aktionen | Erwartetes Ergebnis | Ergebnis | Bewertung | Kommentar |
---|---|---|---|---|---|---|---|---|
IT-SW-HS-001 | Zustandswechsel - Automatik zu Manuell | REQ-310, REQ-312 | Kippschalter mit 12 V versorgt | Schalter kippen | Wechsel von Automatik auf Manuell | Wechsel von Automatik auf Manuell | i. O. | |
IT-SW-HS-002 | Zustandswechsel - Manuell auf Automatik | REQ-310, REQ-312 | Kippschalter mit 12 V versorgt | Schalter kippen | Wechsel von Manuell auf Automatik | Wechsel von Manuell auf Automatik | i. O. |
|
Tab. 4: Ausschnitt aus Integrationstest für den Lampenbetrieb
Betriebsmoduswechsel-Test - Türsteuerung
int main() { // **************************************** // Initialisierung der nötigen Parametern // **************************************** bool bTuerBewegungAuto = false; bool bTouchTuer = false; int nAbstand = 10; // in [cm] bool bKippschalter = false; // **************************************** // Test - Wechsel Automatik/Manuel-Betrieb // **************************************** cout << "*********************************************************************************" << endl; cout << "Test - Wechse Automatik / Manuel - Betrieb" << endl; cout << "------------------------------------------" << endl; for (int i = 1; i <= 10; i++){ if (i % 2 == 0) { bKippschalter = false; } else { bKippschalter = true; } cout << "Input: Kippschalter = " << bKippschalter << endl; for (int j = 1; j <= 5; j++) { TuerBetrieb(bTuerBewegungAuto, bTouchTuer, nAbstand, bKippschalter); } cout << endl; } cout << "******************************************************************************" << endl; // *********************************************** // Test im manuellen Betrieb // *********************************************** // Manueller Betrieb einschalten bKippschalter = false; // *********************************************** // Test im automatischen Betrieb // *********************************************** // Manueller Betrieb einschalten system("pause"); return 0; }
Testfall-ID | Testfall-Name | Anforderungs-ID | Vorbedingungen und Eingänge | Aktionen | Erwartetes Ergebnis | Ergebnis | Bewertung | Kommentar |
---|---|---|---|---|---|---|---|---|
IT-SW-TS-001 | Zustandswechsel - Automatik zu Manuell | REQ-310, REQ-311 | Kippschalter mit 12 V versorgt | Schalter kippen | Wechsel von Automatik auf Manuell | Wechsel von Automatik auf Manuell | i. O. | |
IT-SW-TS-002 | Zustandswechsel - Manuell auf Automatik | REQ-310, REQ-311 | Kippschalter mit 12 V versorgt | Schalter kippen | Wechsel von Manuell auf Automatik | Wechsel von Manuell auf Automatik | i. O. |
|
Tab. 4: Ausschnitt aus Integrationstest für den Türbetrieb
Systemtest
Ergebnis
Zusammenfassung
Lessons Learned
Projektunterlagen
Projektplan
No. | Priorität | Issue | Action | Responsable | Department | Target date | Start date | closed date | status | Komentar
|
---|---|---|---|---|---|---|---|---|---|---|
1 | 1 | Türsteuerung - Motorauswahl | Benchmart des Motors und Bestelung | Dominik H. | Hardware Development | 25.12.2020 | 01.10.2020 | 12.12.2020 | erledigt | 17.11.2020:
|
2 | 1 | Ultrachall Positionierung | Probe von verschiedenen position | Dominik H. | Konstruktion | 25.12.2020 | 01.10.2020 | 12.12.2020 | erledigt | 17.11.2020:
|
3 | 2 | Gehäuse | Prototyp drucken lassen und verbessern | Dominik H. | Test and Calibration | 25.12.2020 | 01.10.2020 | 19.12.2020 | erledigt | |
4 | 2 | Schwellwertbestimmung LDR | Messungen durchführen | Dominik H. | Test and Calibration | 25.12.2020 | 01.10.2020 | 17.12.2020 | erledigt | 17.11.2020
|
8 | 1 | Programmablaufplan | Modellierung des PAP | Isaac Mpidi Bita | Projektleitung/Software | 30.12.2020 | 28.12.2020 | 30.12.2020 | erledigt | 28.12.2020: Warte auf Abstimmung des Programmorientierung |
10 | 2 | Simulationsmodell | Erstellung eines Simulationsmodell in MATLAB/Simulink | Isaac Mpidi Bita | Software Developement | 10.01.2020 | 01.12.2020 | 02.01.2020 | erledigt | |
11 | 1 | Hardware-Entwurf | Erstellung eines funktionaler Harwareentwurf | Isaac Mpidi Bita | Hardware Developement | 10.12.2020 | 01.12.2020 | 06.01.2020 | erledigt | |
11 | 1 | Software-Entwurf | Erstellung eines funktionaler Sofwareentwurf | Isaac Mpidi Bita | Software Developement | 10.12.2020 | 01.12.2020 | 06.01.2020 | erledigt | |
13 | 1 | Verhaltenmodellierung | Erstellung der Stateflow für die verschiedenen Programmsequenzen | Isaac Mpidi Bita | Software Developement | 30.12.2020 | 01.12.2020 | 30.12.2020 | erledigt |
|
Projektdurchführung
Prozessmodell : V-Modell
Modellierungstandard : SysML für das System Design
Software-Archtektur : Objektorientierte Programmierung
Software-Richtlinien : Embedeed Software Engineering
YouTube Video
Ausblick
Weblinks
Literatur
→ zurück zur Übersicht: WS 20/21: Angewandte Elektrotechnik (BSE)