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 3). 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: Unittests zum Testen der Komponenten Integrationstests zum Testen von Module Systemtests zum Testen des gesamten Modells Abnahmetests für die Endabnahme des gesamten Projektes	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.

**Abb.4**: Funktionaler Entwurf - Projekt SmartFarm (Funktionalität)

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

No.	Artikel	Link
1	Lampe
2	LDR-Fotowiderstand	https://www.funduinoshop.com/epages/78096195.sf/de_DE/?ObjectID=54561679
3	RTC-Sensor	https://www.az-delivery.de/products/ds3231-real-time-clock?_pos=1&_sid=4ea98dcb7&_ss=r
4	Relais	https://www.funduinoshop.com/epages/78096195.sf/de_DE/?ObjectPath=/Shops/78096195/Products/A-5-4
5	DC-Motor	https://www.conrad.de/de/p/joy-it-com-motor01-getriebemotor-gelb-schwarz-passend-fuer-einplatinen-computer-arduino-banana-pi-cubieboard-raspbe-1573543.html?hk=SEM&WT.srch=1&WT.mc_id=google_pla&s_kwcid=AL%21222%213%21367270211499%21%21%21g%21%21&ef_id=EAIaIQobChMI74zfs4zD7AIVT-h3Ch2GrQ6AEAQYASABEgI7mvD_BwE%3AG%3As&gclid=EAIaIQobChMI74zfs4zD7AIVT-h3Ch2GrQ6AEAQYASABEgI7mvD_BwE
6	Ultraschallsensor	https://www.funduinoshop.com/epages/78096195.sf/de_DE/?ObjectID=50294801
7	H-Bridge	https://www.reichelt.de/de/de/entwicklerboards-motodriver2-l298n-debo-motodriver2-p202829.html?PROVID=2788&gclid=EAIaIQobChMI5tjlx43D7AIVA-h3Ch1_bwO5EAQYASABEgJe9_D_BwE&&r=1
8	2x Touchsensor	https://www.funduinoshop.com/epages/78096195.sf/de_DE/?ObjectID=128598580
9	2x Kippschalter	https://www.amazon.de/Rovtop-Kippschalter-beleuchtet-Schalter-Wippschalter/dp/B079L4K7TF/ref=pd_sbs_4?pd_rd_w=1AiWR&pf_rd_p=ad79fb78-2eb6-4fd8-b228-cb6e6b4589d9&pf_rd_r=6GW2EA97VRAGX5AG4KGQ&pd_rd_r=bbab490b-49ca-425d-9b36-bb57fb166b01&pd_rd_wg=ufN1J&pd_rd_i=B079L4K7TF&psc=1

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

Wird das System mit Spannung versorgt und eingeschaltet, so befindet sich das System im Betriebszustand. Dort ist zwischen Automatik und Manuell zu wählen. Der Zustandsübergang wird durch
einen Kippschalter gewährleistet. Diese wird in beide Subsysteme für sich Implementiert. Somit ist gewährleistet, dass beide System unabhängig voneinander funktionieren. D.h. wenn z.B. die
Helligkeitssteuerung sich im Automatik-Betrieb befindet, gäbe es die Möglichkeit die Tür Manuel zu bewegen. Außerdem wurde ein Kippschalter ausgewählt, aufgrund der Eindeutigkeit der Schalter-
position. Diese ermöglichen einen sicheren und dauerhaften Zustandswechsel.

Tageslichtabfrage mit Hysterese

Die Tageslichtabfrage gibt der Status der Außenhelligkeit an. Diese sagt entweder Hell oder Dunkel in der Abhängigkeit von einem Schwellwert aus.

Spezifikation der Türsteuerung

Im Folgenden werden alle Zustandsverhalten der Türsteuerung dargestellt.

Türstatus - Manuell-Betrieb

Hier handelt es sich, um die Türsteuerung im manuellen Betrieb. Der Zustandswechsel wird anhand des Tür-Touch-Sensors gewährleistet.

Zeiterfassung für die Türsteuerung

Im Automatikbetrieb darf sich die Tür nur an bestimmten Zeiten bewegen. Eine Bewegung der Tür ist nur zwischen 5 Uhr und 23 Uhr möglich. Außerhalb dieser Zeit
darf sich die Tür im Automatikbetrieb sich nicht bewegen.

Türstatus - Automatikbetrieb

Im Automatikbetrieb ergibt sich folgenden Zustand. Die Tür muss bei Dunkelheit zufahren und bei Helligkeit auffahren. Die unteren bzw. oberen Position der Tür wird anhand Ultraschall-Sensor erkannt.
Diese sind fest-definierte Abständen zwischen US-Sensor und Tür und Lautet:

40 ± 1 cm Tür ist zu
10 ± 1 cm Tür ist auf

Helligkeitszustand	Zeitflag	Türbewegung
dunkel	Tür darf sich bewegen	Bewegung nach Unten
dunkel	Tür darf sich nicht bewegen	-
hell	Tür darf sich bewegen	Bewegung nach oben
hell	Tür darf sich nicht bewegen	-

Spezifikation der Lampensteuerung

Im Folgenden werden alle Zustandsverhalten der Helligkeitssteuerung dargestellt.

Lampenstatus - Manuell-Betrieb

Hier handelt es sich, um die Helligkeitssteuerung im manuellen Betrieb. Der Zustandswechsel wird anhand des Lampe-Touch-Sensors gewährleistet.

Zeiterfassung für die Helligkeitssteuerung

Im Automatikbetrieb darf die Lampe sich ebenfalls nicht willkürlich an- und ausgehen. Die Lampe darf im ersten Schicht zwischen 5 Uhr und 8 Uhr und im zweiten SChicht zwischen 17 Uhr und 20 Uhr angehen.
Anderfalls darf es aus bleiben.

Lampenstatus - Automatikbetrieb

Die Lampensteuerung bzw. Helligkeitssteuerung im Automatikbetrieb ergibt sich folgenden Zustände. Die Lampe darf nur angehen, falls es dunkel ist, und falls das Lampenflag auf dem vorherigen Zustandsdiagramm 1 ist.

Helligkeitszustand	Lampenflag	Türbewegung
dunkel	0	Licht aus
dunkel	1	Licht an
hell	0	Licht aus
hell	1	Licht aus

Hardwarespezifikationen

In folgenden werden die Hardware-Komponentenspezifikationen von einigen wichtigen Hardware-Komponenten.

DC Motor

ID	Kapitel	Inhalt
KS-MO-000	1	Aufgabe
		Öffnen der Schließen der Tür über eine Seilwinde
KS-MO-001	2	Schnittstelle
		Ansteuerung über die H-Bridge
KS-MO-002	3	Technische Daten
		DC-Motor
		12 V Spannungsversorgung
		Geschwindigkeit: 6 RPM
		Dauerstrom = 0,82 A; Leerlaufstrom = 0,12 A

Ultrashallsensor

ID	Kapitel	Inhalt
KS-US-000	1	Aufgabe
		Misst der Abstand zu Tür und muss bestätigen, ob die Tür zu oder auf ist.
KS-US-001	2	Schnittstelle
		VCC
		Trig
		Echo
		GND
KS-US-002	3	Technische Daten und Messverfahren
		Triangulation
		Laufzeit
KS-US-003	4	Berechnung
		Laufzeit messung mittel Schallgeschwindigkeit

LDR-Fotowiderstand

ID	Kapitel	Inhalt
KS-LDR-000	1	Aufgabe
		Tageslicht bzw. Helligkeitsaufnahme
KS-LDR-001	2	Schnittstelle
KS-LDR-002	3	Technische Daten und Messverfahren
		Widerstandsmessung
KS-LDR-003	4	Berechnung
		Spannungszteiler gleichung aufstellen.

RTC-Zeitsensor

ID	Kapitel	Inhalt
KS-RTC-000	1	Aufgabe
		Messung der echten Uhrzeit in Stunden.
KS-LDR-001	2	Schnittstelle - Pins
		VCC
		GDN
		SDA - Serial Data Pin
		SCL - Serial Clock Pin
		SQW - Square Wave Output Pin
		32K - 32 K Oscillator

Implementierung

In diesem Abschnitt erfolgt die Softwareumsetzung. Hierfür wird zunächst das Programmablaufplan erstellt. Des Weiteren wird das Gesamtsystem im MATLAB/Simulink modelliert. Anschließend erfolgt
das Codieren mittels einen Hochsprache C/C++.

Programmablaufplan

Der Programmablaufplan wird mittels eines Activity-Diagramms nach SysML-Standard ermittelt.

Türsteuerung im Automatik-Betrieb

Sensor-Signale werden für die Tageslichtaufnahme und die Uhrzeit werden jeweils von der Funktionen GetHelligkeit und GetZeit. Das Signal wird dann in der Helligkeitszustand-Statediagramm weitergegeben,
Der Statediagramm wird dann Auskunft geben, ob es Hell oder Dunkel draußen ist. Das Zeitsignal wird in dem Zustand "Zeiterfassung für die Tür"-Statediagramm geführt. Dieser wird dann sagen, ob die
die Tür in diesem Tageszeit sich steuern lassen kann. Anhand beide Signale wird dann die durchzuführende Aktion gemäß Türstatus-Statediamme entschieden. Die Funktion Türsteuerung sammelt
zusätlich Daten aus dem Ultraschall-Sensor, damit er an der Motor rechtzeitig einen Stopp-befehl schicken kann.

Helligkeitssteuerung im Automatik-Betrieb

Analog wird es bei Lampensteuerung aufgestellt.

Modellierung und Simulation des Stall-Systems in MATLAB-Simulink

Modelle werden verwendet, um die Idee darzustellen. Das Modell ist ein Abbild der Realität. Modelle helfen dabei:

ein System zu visualisieren,
ein System zu dokumentieren und
Programmcode oder einen Coderahmen aus den Modelldaten zu generieren.

Hierfür wird MATLAB/Simulink verwendet für die Modellierung. Zu sehen sind die verschiedenen Teile der Softwarearchitektur mit der Sensorsignalaufbereitung, hier den "Sensoren"-Block, beide Steuerungsfunktionen und
die Aktuatorausgabe. Aktuatorausgabe wurde auf der ersten Ebene Modelliert um die Bedienung des Modells zu vereinfachen. In der C/C++-Code wird es in einer eigenen Klasse programmiert. Aufgrund der Benutzerfreundlichkeit
wurde die Sensoreingabe mittels MATLAB-Dashboards realisiert. Dadurch kann der Entwickler den Code mühelos programmieren und ganz wichtig verschiedene Zustände simulieren, damit sinnvolle Use-Cases erstellt und getestet
werden können

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
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

Ergebnis

ID	Typ (I = Info, A = Anforderung)	Kapitel	Inhalt	Status	Kommentar
REQ-000	I	0	Projektziel	erfüllt
REQ-001	A	0.1	Mit Sensorsystemen und Aktuatoren die Tierhaltung im Einklang mit den Tieren erleichtern und optimieren.	erfüllt
REQ-100	I	1	Functional Requirements	erfüllt
REQ-110	A	1.1	Ein mechatronisches System für die Helligkeit- und die Türsteuerung muss entworfen werden.	erfüllt
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.	erfüllt
REQ-150	A	1.4	Die Tür muss bei ausreichende Außenhelligkeit aufgehen, andersfalls muss es zu sein.	erfüllt
REQ-200	I	2	Physical Requirements	erfüllt
REQ-210	A	2.1	Ein Gehäusekonzept muss erarbeitet werden.	erfüllt
REQ-210	A	2.2	Der ausgewählte Motor muss die Tür heben können.	erfüllt
REQ-230	A	2.3	Die Masse der Tür muss auf keinen Fall ein Wert von 5 Kg überschreiten.	erfüllt
REQ-240	A	2.4	Die Länge des Seils muss eine komplette Öffnung bzw. Schließung der Tür ermöglichen	erfüllt
REQ-250	A	2.5	Die Zugfestigkeit des Seils muss dem Heben und Senken der Holztür standhalten.	erfüllt
REQ-300	I	3	Usability Requirements	erfüllt
REQ-310	A	3.1	Eine alternative Lösung zur manuelle Ansteuerung muss angeboten werden.	erfüllt
REQ-311	A	3.1	Es muss eine Möglichkeit bestehen, jeder Zeit die Tür zu öffnen bzw. zu schließen.	erfüllt
REQ-312	A	3.2	Es muss eine Möglichkeit bestehen, jeder Zeit die Beleuchtung an- bzw. auszuschalten.	erfüllt
REQ-400	I	4	Business Requirements	x
REQ-500	I	5	Performance Requirement	erfüllt
REQ-520	A	5.2	Der Motor darf sich maximal mit einer Geschwindigkeit von 9 RPM drehen.	erfüllt	Die Tür bewegt sich mit einer konstante Geschwindigkeit von 6 RPM.
REQ-600	I	6	Non functional Requirement	erfüllt
REQ-610	A	6.1	Toolanforderungen	erfüllt
REQ-611	A	6.1.1	Das Projekt geht bei der Entwicklung nach dem V-Modell vor.	erfüllt
REQ-613	A	6.1.3	Als Versionsverwaltungstool wird SVN oder Git eingesetzt.	erfüllt
REQ-620	A	6.2	Qualitätsicherung	erfüllt
REQ-620	A	6.2	Sowohl für die implementierte Software als auch für die Modelle müssen geeignete Tests erstellt werden: Unittests zum Testen der Komponenten Integrationstests zum Testen von Module Systemtests zum Testen des gesamten Modells Abnahmetests für die Endabnahme des gesamten Projektes	erfüllt
REQ-700	I	7	Extended Requirement	erfüllt
REQ-720	A	7.2	Die echte Uhrzeit muss für den Ansteuerung erfasst werden.	erfüllt
REQ-800	I	7	Meilensteine	erfüllt

Zusammenfassung

Das Projekt "SmartFarm" wird nicht nur für die Lehrveranstalltung entwicklelt. Die Idee kommt aus Beobachtung einer reelen System, die durch manueller menschlischer Arbeit langsam aufwändig und
sehr schwer zu koordinieren bei den vielen Nebenbeschätigung geworden sind. Daher bietet sich die Gelegenheit durch Automatisierung die Kontrolle über die Helligkeit im Stall und die Tür des Stall
zu verbessern.

Lessons Learned

Projektunterlagen

LOP - List Of Open-Point

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: Kein BLDC --> Zu aufwendig DC Motor mit Getriebe --> große Drehmoment
2	1	Ultrachall Positionierung	Probe von verschiedenen position	Dominik H.	Konstruktion	25.12.2020	01.10.2020	12.12.2020	erledigt	17.11.2020: Verschiedene Position ausprobieren und schauen, ob die Distanz korrekt ermittelt wird.
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 Messung an verschiedenen Tagen durchführen mit vielen und wenigen Sonnenstunden Messung mit Kunststoff-Kuppe testen
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

Gannt Chart

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

↑ Datendanken verstehen (2020): V-Modell. [1] Letzter Aufruf: 18.07.2020.
↑ Datendanken verstehen (2020): V-Modell. [2] Letzter Aufruf: 18.07.2020.

Referenzfehler: Das in <references> definierte <ref>-Tag mit dem Namen „Systems Engineering“ wird im vorausgehenden Text nicht verwendet.

[Datendankverstehen-1] Datendanken verstehen (2020): V-Modell. [1] Letzter Aufruf: 18.07.2020.

[ionos_VModell-2] Datendanken verstehen (2020): V-Modell. [2] Letzter Aufruf: 18.07.2020.

[1]

[2]

SmartFarm