SmartFarm: Unterschied zwischen den Versionen

Aus HSHL Mechatronik
Zur Navigation springen Zur Suche springen
Zeile 1.920: Zeile 1.920:


==== YouTube Video ====
==== YouTube Video ====
{{#ev:https://www.youtube.com/watch?v=d51bS0bcJSA&ab_channel=IsaacMpidi|450px|left}}
<br clear=all>


= Ausblick =
= Ausblick =

Version vom 11. Februar 2021, 22:01 Uhr

Autoren: Isaac Mpidi Bita, Dominik Hermelingmeier
Betreuer: Prof. Göbel


→ zurück zur Übersicht: WS 20/21: Angewandte Elektrotechnik (BSE)

Abb. 1: SmartFarm


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 Kozept "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. Sie lassen sich zu den fünf Oberpunkten SmartLight, SmartDoor, SmartTracking, SmartFeed, SmartWater und SmartClimate zusammenfassen. SmartLight bezieht sich auf die Helligkeitssteuerung im Stall und SmartDoor auf die Türsteuerung. SmartTracking umfasst die Positionserfassung der Tiere. SmartFeed und SmartWater beziehen sich auf die Versorgung der Tiere. Klimatische Daten werden im Gebiet SmartClimate sowohl für den Stall als auch für die Legenester zur Überwachnung des Lege- und Brutverhaltens ermittelt. Ein perfektes System erfordert die Zusammenarbeit zwischen den verschiedenen Bereichen. Verschiedene Möglichkeiten für die Umsetzung des Gesamtsystems mit den Teilsystemen sind in dem Brainstorming in Abbildung 2 und 3visualisiert.

Abb. 3: SmartFarm - Brainstorming


Der Fokus dieses mechatronischen Projekts liegt auf den Teilsystemen der Tür- (s. SmartDoor)und Helligkeitssteuerung (s. SmartLight) in einem Hühnerstall (s. Abbildung 2). Zudem besteht die Möglichkeit, sowohl die Tür als auch die Lampe manuell anzusteuern.

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.

Istsituation

Als Istsituation existiert ein Stromanschluss und eine Tür, die manuellen geöffnet und geschlossen werden kann (s. Abbildung 1). Des Weiteren ist für die Lichtsteuerung eine Tageslichtlampe bereits im Stall eingebaut und angeschlossen.

Für einen ersten Eindruck ist der Stall (Istsituation) in den folgenden Bilder dargstellt. Im Abbildung 2 ist links die Tür mit der Stromversorgung erkennbar.

  • Hühnerstall hinten

    Hühnerstall hinten

  • Hühnerstall hinten

    Hühnerstall hinten

V-Modell als Vorgehensmodell

Abb.4: Das V-Modell (eigene Abbildung in Anlehnung an [1])

Das V-Modell ist ein Prozessmodell zur Systementwicklung. Dieses Modell wird für die Entwicklung des Projekts "SmartFarm" verwendet und gliedert sich schwerpunktmäßig in die Entwurfsphase, Implementierung und Testphase. Das Ergebnis bzw. Ziel ist ein fertiges Produkt (s. Abbildung 4). 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 einem Lastenheft in Form einer Excel-Tabelle zusammengefasst. Diese gliedert sich entsprechend des SysML-Standards in die folgenden Punkte:

  1. Projektziel
  2. Functional Requirements
  3. Physical Requirements
  4. Usability Requirements
  5. Business Requirements
  6. Performance Requirements
  7. Non-functional Requirements
  8. Extended Requirements
  9. 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 diesem Entwurf wird eine BOM bzw. Stückliste der Bauteile für die Realisierung des Projektes ermittelt.

Gesamtsystem

Wie in Abbildung 5 zu sehen ist, gliedert sich das Projekt "SmartFarm" in mehrere Bestandteile. Bei diesem Entwurf ist das Ziel das System in der Funktionalität abzugrenzen und
einen Rahmen für das Uni-Projekt aufzustellen. Das Stallsystem/Gesamtsystem besteht aus zwei Subsystemen bzw. Teilsystemen. In diesem Projekt wird die Helligkeits- und die Türsteuerung betrachtet (s. Abbildung unten)
.

Bei der Helligkeitssteuerung wird eine Tageslichtlampe für ausreichend Helligkeit im Stall sorgen, wenn die Sonne gerade nicht scheint. Wesentliche Anforderungen der Helligkeitssteuerung sind in der REQ-140 beschrieben. 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 von der Zeit- als auch von Außenhelligkeit abhängig.


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


Softwarearchitektur

Im Folgende wird die Softwarearchitektur des Systems beschrieben. Die Software spielt bei Embedded-Systemen eine wesentliche Rolle. Das Ziel hierbei ist die klare
und funktionsbasierte Abgrenzung von verschiedenen Softwarekomponenten. Diese Anforderungen basieren auf dem Einsatz von objektorientierter Programmierung.
Änderungen im Laufe des Projekts lassen sich einfach und schnell in die Software einbringen. Die Softwarearchitektur besteht aus folgenden Elementen:

  • Main-Funktion
  • Signalaufbereitung: Schnittstelle zwischen Sensoren und Software
  • Aktuatorausgabe: Schnittstelle zwischen Software und Aktuatoren
  • Türsteuerung
  • Helligkeitssteuerung

Die Klasse "Signalaufbereitung" bezieht sich auf die Sensoren das System. Hier werden die verschiedenen Sensoren beim Systemstart initialisiert. Während des Systembetriebs
werden alle Sensorsignale aufgenommen und zur Verfügung gestellt. Die Klasse "Aktuatorausgabe" leitet die Befehle an den Aktuatoren weiter. Die eigentliche Automatisierungs-
funktionen werden in der jeweiligen Klasse "Tür- und Helligkeitssteuerung" zusammen gebracht. Die Main-Funktion ist das Herzstück des Programms. Hier wird der Programmabfluss durch Verweise
und verschiedene Funktionsaufrufe gesteuert.

Abb. 6: Softwarearchitektur - Projekt SmartFarm


Hardwarearchitektur

Eingabe bzw. Sensoren:

  • LDR: Helligkeitsaufnahme
  • Touch-Sensor: Manuelle Ansteuerung der Tür und der Lampe
  • Ultraschallsensor: Erfassung der Türposition
  • Kippschalter: Wechsel vom Betriebsmodus
  • RTC-Sensor: Angabe der echten Uhrzeit


Mikrocontroller: Systemsteuereinheit


Ausgabe bzw. Aktuatoren:

  • UV-Lampe: erzeugt künstliches Tageslicht im Stall
  • Motor: öffnet oder schließt die Tür
Abb. 7: Funktionaler Entwurf - Projekt SmartFarm


Stückliste

No. Artikel Link


1 Lampe https://www.obi.de/e14-led/osram-led-lampe-classic-t-form-klar-e14-2-8w-250-lm-tageslicht-eek-a-/p/8471617


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.amazon.de/gp/product/B07LF7V1Y3/ref=ppx_yo_dt_b_asin_title_o01_s00?ie=UTF8&psc=1


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

Abb. 8: Funktionaler Entwurf - Projekt SmartFarm


TE-Hardware

Abb.8: Funktionaler Entwurf - Projekt SmartFarm


Software-Hardware-Schnittstelle

Die Hardware-Software-Schnittstellen sind die Module "Sensor-Signalaufbereitung" und "Aktuatorausgabe". Damit die Software das richtige Element steuert, wird eine sogenannte Parameter-Datei erstellt.
In dieser ist festgelegt, 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.
Der Aufbau gliedert sich in die Software- und Hardwarespezifikationen auf.

Softwarespezifikationen

Betriebsmodis - Stallsystem

Wird das System mit Spannung versorgt und eingeschaltet, so befindet sich das System im Betriebszustand. Es kann zwischen einem automatischen und manuellen Betrieb gewählt werden. Der Zustandsübergang wird durch
einen Kippschalter gewährleistet. Beide Systeme sind unabhängig voneinander implementiert. Das heißt, dass die Tür auch manuell runtergefahren werden kann, wenn sich die Lichtsteuerung im automatischen Zustand befindet. Leuchtet das Lämpchen am Kippschalter, befindet sich das jeweilige Subsystem im Modus "Automatik".

Abb.9: State Machine - Betriebsmodis des Stall-Systems


Tageslichtabfrage mit Hysterese

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

Abb.1: State Machine - Betriebsmodis des Stall-Systems


Zur Schwellwertbildung wurden mehrere Helligkeitsmessungen direkt im Stall ausgeführt. In dem Diagramm unten sieht man die Helligkeitswerte über die Zeit aufgetragen.

Abb. Helligkeit im Hühnerstall:


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 ausgeführt.

Abb.1: State Machine - Betriebsmodis des Stall-Systems


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 Zeitspanne darf sich die Tür im Automatikbetrieb nicht bewegen.

Abb.1: State Machine - Betriebsmodis des Stall-Systems


Türstatus - Automatikbetrieb

Im Automatikbetrieb muss die Tür bei ausreichender Dunkelheit zufahren und bei ausreichender Helligkeit wieder auffahren. Die unteren bzw. oberen Position der Tür wird anhand eines Ultraschallsensors erkannt.
Der Zustand der Tür wird anhand der folgenden Definition bestimmt:

  • 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 -
Abb.1: State Machine - Betriebsmodis des Stall-Systems


Spezifikation der Lampensteuerung

Im Folgenden wird das Zustandsverhalten der Helligkeitssteuerung dargestellt.

Lampenstatus - Manuell-Betrieb

Hier handelt es sich, um die Helligkeitssteuerung im manuellen Betrieb. Der Zustandswechsel wird mit dem Lampe-Touch-Sensor ausgeführt.

Abb.1: State Machine - Betriebsmodis des Stall-Systems


Zeiterfassung für die Helligkeitssteuerung

Im Automatikbetrieb geht das Licht nur zu bestimmten Zeiten an. Im Stall muss es ganzjährig von mindestens 7 Uhr bis mindestens 19 Uhr hell sein (s. REQ 141).

Abb.1: State Machine - Betriebsmodis des Stall-Systems


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
Abb.1: State Machine - Betriebsmodis des Stall-Systems


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

Ultraschallsensor

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

Entwicklung eines Prototypen

Das System wird anhand des V-Modells entwickelt. Um die Entwurf-, Implementierungs- und Testphase bestmöglich umzusetzen, wurde ein Prototyp entwickelt. Dies bietet die Möglichkeit viele Dinge auszuprobieren, bevor die finale Version im Stall eingebaut wird. Der Protoyp wurde erst in Abbildung skizziert und dann aufgebaut (s. ).

Abb. 9: Skizze Prototyp


Entwicklung der Hilfsplatine

Um das ganze System modular zu trennen, werden neben den Aktoren und Sensoren auch das Breadbord vom Mikrocontroller getrennt. Alle analogen und digitalen I/O Pins werden auf die Platine übertragen. Es existieren viele VCC 5V und GND Anschlüsse für den Anschluss der Sensoren. Zur Anschluss der Tageslichtlampe existiert eine 230V Eingangsspannung und für den Motor eine 12 V Eingangsspannung. Da die 230 V Spannung einen risikoreichen Anschluss darstellt, ist dies nur eine Übergangslösung. Der Motor wird über die zwei Outputs in der Motorschaltung gesteuert. Für die Schaltung der Helligkeitserfassung wird ein Widerstand mit 20 Ohm verwendet, der in der Hilfsplatine direkt mit verlötet ist. Wie eingangs im Brainstorming (s. Abbildung ) visualtisiert existieren viele Erweiterungsmöglichkeiten als Subsysteme im Gesamtsystem SmartFarm. Dafür wurden vier Reserve Inputs und eine Vielzahl an Pins eingeplant. Alle Bestandteile der Platine sind in den folgenden beiden Abbildungen und von der Ober- und Unterseite dokumentiert.

Abb. : Oberseite der Hauptplatine.png


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.


Abb.1: State Machine - Betriebsmodis des Stall-Systems


Helligkeitssteuerung im Automatik-Betrieb

Analog wird es bei Lampensteuerung aufgestellt.

Abb.1: State Machine - Betriebsmodis des Stall-Systems


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

Abb.1: Modellierung des Stallsystems mit MATLAB/Simulink



Abb.1: Modellierung der Türsteuerung entsprechend Programmablaufplan



Abb.1: Modellierung der Helligkeitssteuerung entsprechend Programmablaufplan


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

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
  • Prototypen-Vorrichtung

    Prototypen-Vorrichtung

  • Hühnerstall bei Dunkelheit

    Hühnerstall bei Dunkelheit

  • Betriebsmodus-Auswahl

    Betriebsmodus-Auswahl

  • Projektzustands

    Projektzustands

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

Für die Entwicklung des Projekts wurde hauptsächlich drei Bereiche benötigt:

  • Software-Entwicklung
  • Hardware-Entwicklung
  • Konstruktion

Die Software-Entwicklung sollte eine Software anbieten, die folgende Anforderungen sollte:

  • Anpassbarkeit bzw. Adaptierbarkeit
  • Skalierbarkeit
  • Zuverlässigkeit
  • Effizienz

Die Herausforderung besteht darin die Software mittels moderne Softwarewerkzeuge und -techniken als Bindeglied zwischen Kundenwunsch und Systemverhalten zu programmieren, sodass möglichst alle Wünschen
bei einer hundertprozentigen Zuverlässigkeit und Korrektheit des Systems zu erfüllen. Zusätzlich sollte die Software gewährleisten, dass beide Systeme unabhängig voneinander funktionieren und keine Signalverluste
oder Signalfehler z.B. aufgrund der Dateninkonsistenz entsteht.

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

Abb.1: State Machine - Betriebsmodis des Stall-Systems


Projektdurchführung

Prozessmodell : V-Modell

Modellierungstandard : SysML für das System Design

Software-Archtektur : Objektorientierte Programmierung

Software-Richtlinien : Embedeed Software Engineering

YouTube Video

EmbedVideo erkennt den Videodienst „https://www.youtube.com/watch?v=d51bS0bcJSA&ab_channel=IsaacMpidi“ nicht.


Ausblick

Weblinks

Literatur

  1. ↑ Datendanken verstehen (2020): V-Modell. [1] Letzter Aufruf: 18.07.2020.
  2. ↑ Datendanken verstehen (2020): V-Modell. [2] Letzter Aufruf: 18.07.2020.
Abgerufen von „https://wiki-test.hshl.de/wiki/index.php?title=SmartFarm&oldid=74412“