Dieser Wiki-Beitrag ist Teil eines Projektes, welches im Rahmen des Fachpraktikums Elektrotechnik im 5. Semester Mechatronik absolviert wurde. Ziel des Beitrags ist es, eine nachhaltige Dokumentation zu schaffen, welche die Ergebnisse festhält und das weitere Arbeiten am Projekt ermöglicht.

Autoren: Martin Böhner, Franziska Koch und Thorsten Solzbach

Betreuer: Prof. Dr.-Ing. Mirek Göbel

Aufgabenstellung

Entwerfen einer autonomen Tischlampe mit Hilfe eines Arduino-Boards.

Schwierigkeit

Der Schwierigkeitsgrad wurde nach eigenem ermessen festgelegt und ist als Mittel festzulegen.

	Schwierigkeitsgrad
***	Mittel

Erwartung an das Projekt

Projekt in Aufgabenbereiche aufteilen
Lösungsfindung für den Projektauftrag mit Hilfe von ingenieurmäßigen Methoden aus dem Studium
Einarbeitung in die Arduino-Programmieroberfläche
Beschaffungsliste für die benötigten Teile erstellen und weiterleiten
Zusammenbau der eingebundenen Komponenten
Einbindung des Arduino-Boards zur Ansteuerung des Leuchtmittels
Ausführliche Dokumentation der erarbeiteten Inhalte und einpflegen dieser auf die Wiki-Plattform der Hochschule Hamm-Lippstadt
Ein Video für die Öffentlichkeitsarbeit der Hochschule Hamm-Lippstadt, über die Ergebnisse dieses Projektes auf die Plattform Youtube hochladen

Einleitung

Das Projekt 20 hat die Aufgabenstellung "Entwerfen einer autonomen Tischlampe mit Hilfe eines Arduino-Boards". Es soll dazu eine autonome Beleuchtung durch eine Tischlampe realisiert werden, welche bei einem definierten Helligkeitsgrad einschaltet und die eigene Helligkeit, der Umgebenden anpasst. Dies soll eine konstante Helligkeit im Umgebungsbereich der autonomen Tischleuchte schaffen. Für die Umsetzung der Helligkeitsregelung soll unter anderem ein Arduino-Board eingesetzt werden. Der Umgang mit diesem Mikrocontroller wurde durch das Praktikum kennengelernt. Durch dieses Projekt wurden die erlangten Fähigkeiten vertieft. Der grundlegende Aufbau und die Umsetzung dieses Projektes wird in den nachfolgende Punkten genauer betrachtet und erklärt, des weiteren befinden sich alle Inhalte und Dokumente zu diesem Projekt in dem dazugehörigen SVN-Verzeichnis.

Projektdurchführung

Die Durchführung des Projektes wird anhand des Projektplans aufgezeigt, dieser wird im anliegenden Kapitel "Projektplan" aufgezählt und erläutert. Wichtig für das weitere Verständnis ist, dass die Projektaufgabe von den Projektteilnehmern aufgestellt und an keiner Vorlage angelehnt war. Somit ist dieses Projekt aus einer kompletten Eigeninitiative entstanden und entsprechend umgesetzt worden.

Projektplan

Dies ist der fundamentale Leitfaden für die Umsetzung der gegenwärtigen Projektaufgabe. Hierbei musste eine ausführliche und strukturierte Vorgehensweise aufgestellt und die Aufgabe noch einmal separat unter den Gruppenteilnehmern aufgeteilt werden. Somit konnte jeder die erhaltenen Arbeitspakete in seiner Eigenstudienzeit bearbeiten. Die nachfolgenden Aufteilung wird jeweils unter deren Punkten genauer erläutert:

Aufstellen und ermitteln einer Projektaufgabe

Bei dem ersten Praktikumstermin wurde eine eigene Projektaufgabe erstellt und anschließend in einem detaillierten Rahmen beschrieben.

Definierte Projektaufgaben mit dem Dozenten abstimmen

Absprache und Festlegung der Projektaufgabe mit dem Dozenten, so dass diese auch alle wesentlichen Praktikumsanforderungen erfüllt.

Morphologischen Kasten zur Lösungsfindung aufstellen

Der morphologische Kasten wurde für die Findung der optimalen Lösung eingesetzt. Dieser listet die eingebunden Schnittstellen tabellarisch auf und stellt sie verschiedenen Lösungsvarianten gegenüber.

Der morphologische Kasten für die Lösungsfindung für das Projekt 20: Autonome Tischleuchte^[2].

Die Skizzen für die Lampenform eins bis fünf aus dem morphologischen Kasten.

Skizze 1 für die Lampenform aus dem morphologischen Kasten: ^[3].

Skizze 2 für die Lampenform aus dem morphologischen Kasten: ^[4].

Skizze 3 für die Lampenform aus dem morphologischen Kasten: ^[5].

Skizze 4 für die Lampenform aus dem morphologischen Kasten: ^[6].

Skizze 5 für die Lampenform aus dem morphologischen Kasten: ^[7].

Das Ergebnis aus dem morphologischen Kasten ist mit den hellblauen Punkten ausgewählt und mit einer roten Verbindungslinie gekennzeichnet. Somit steht fest, dass die Lampenform der Skizze 2 ausgewählt wurde. Das Gehäuse soll aus Holz bestehen und der ausgeleuchtete Bereich begrenzt sich auf die Beleuchtung des Arbeitsplatzes. Für das Leuchtmittel sollen LED-Streifen verwendet werden, der Spannungsbereich begrenzt sich auf 5VDC und das Ein-/Ausschalten wird mit einem Lichtwiderstand gesteuert. Die Programmieroberfläche sowie die Schnittstelle für die elektrischen Bauteile, wird über das Arduino-Board realisiert.

Beschaffung von benötigten Bauteilen

Die erarbeiteten Inhalte des morphologischen Kastens wurden für die Auswahl der zu bestellenden Bauteile benötigt. Dazu wurde eine Bestellliste angelegt, welche an dem Projektplan als Tabelle anliegt. Es gab dazu eine vorgegebene Liste von Zulieferern der Hochschule, welche entsprechend berücksichtigt wurde. Für dieses Projekt konnten alle benötigten Bauteile von Conrad Electronics bestellt werden.

Zeichnungen für die Tischleuchte anlegen

Nach dem Erhalt der Bauteile wurden diese noch einmal separat betrachtet und vermessen. Dies ist nötig gewesen um ein sauberen und sicheren Einbau der Bauteile zu gewährleisten. Anschließend daran konnten die Zeichnungen für die Tischleuchte erstellt werden, diese befinden sich unter dem Punkt Unterlagen als PDF-Dokument. Eine Besonderheit für die Platzierung der Bauteile war der Lichtwiderstand. Dieser wurde außerhalb des Beleuchtungsfeldes des Leuchtmittels angebracht. Dies wurde durch die Projetkteilnehmer festgelegt, weil die autonome Tischleuchte sonst die geforderte Aufgabenstellung nicht erfüllen kann.

Anfertigen von Bauteilen und zusammenfügen der Komponenten

Die Tischleuchte sollte aus Holz gefertigt werden, dies kann dem morphologischen Kasten entnommen werden. Die angefertigten Holzteile werden dann miteinander Verleimt, falls nötig werden diese nachträglich durch Nägel oder Tacker verstärkt. Für das bessere Verständnis ist die Montagereihenfolge im Folgenden nochmal aufgelistet:

1. Anfertigen der Gehäusebauteile unter Berücksichtigung der erstellten Zeichnungen und Vorgaben

2. Zusammenbau der Gehäusebauteile (Verbindung durch: Leim, Nägel oder Tacker)

3. Einbindung der elektrischen Komponenten

4. Verdrahtung der elektrischen Komponenten mit dem Arduino-Board sowie in der anliegenden Skizze ^[8]

Benötigte Werkzeuge

Tabelle mit Benötigten Werkzeugen: ^[9]

Nr.:	Werkzeug:	Anwendungsbereich:
1.	Holzsäge / Kappsäge	Zuschnitt der Holzelemente
2.	Schleifpapier	Schleifen der Holzelemente um eine glatte und saubere Oberfläche zu erhalten
3.	Leim	Wird für das Verbinden der Holzelemente verwendet
4.	Druckluft	Säubern der Oberflächen für das Verleimen
5.	Hammer	Für das Einschlagen von Nägeln
6.	Tacker	Für das Vertackern von Holzbauteilen
7.	Abisolierwerkzeug	Anpassen von Kabellängen und abisolieren von Kabelenden

Programmierung des Arduino-Boards

Die Programmierung des Arduino-Boards erfolgte in der Firmeneigenen Arduino-Software. Hierzu wurde die Internetseite https://github.com/adafruit/Adafruit_NeoPixel zur Hilfe genommen, weil dort eine benötigte Library zur Verfügung steht.

Ausführliche Tests und Fertigstellung der technischen Umsetzung

Nachdem alle vorherigen Punkte umgesetzt wurden, musste die autonome Tischlampe noch einmal ausführlich getestet werden. Ermittelte Probleme wurden entsprechend gelöst. Dies erstreckte sich über: Die Anpassung der Lichtempfindlichkeit des Lichtwiderstandes (erfolgte in der Arduino-Software), sowie die Vergrößerung der Einführung für die Spannungsversorgung der Steuereinheit

Dokumentation und Evaluierung der Ergebnisse

Die nachhaltige Dokumentation bei solch einem Projekt ist ein wesentlicher Grundstein für das Nachvollziehen von Umsetzungsschritten. Aus diesem Grund wurden erst in einem Word-Dokument die erarbeiteten Inhalte festgehalten. Kurze Zeit danach begann das Einpflegen des Wiki-Artikels. Dies hat den großen Vorteil, dass ein Verlauf von Änderungen oder Anpassungen ersichtlich ist, welche das Projekt über dessen Umsetzungszeit erfährt. Die Ergebnisse werden in einem späteren Punkt dieses Artikels genauer beschrieben.

Bestellliste

Bestellliste in einer tabellarischen Form: ^[10]

Nr.:	Artikel:	Artikelbeschreibung:	Menge in Stück:	Kosten in [€]:	Gesamtbetrag in [€]:	Lieferant:
1.	Lichtwiderstand Iduino SE012 1St. 5 V/DC	Lichtwiderstand für die Helligskeitsmessung der Umgebung	1	2,95	2,95	Conrad Electronics
2.	Seeed Studio Erweiterungsmodul Passend für (Arduino Boards)	Leuchtmittel für die Tischleuchte	1	19,95	19,95	Conrad Electronics
3.	Raspberry Pi® Verbindungskabel Bunt RB-CB3-50 Raspberry Pi®	Verbindungskabel für den Zusammenbau	1	7,99	7,99	Conrad Electronics
4.	Arduino Board UNO 65139 ATMega328	Mikrokcontroller für das Umsetzen der Programmierung	1	7,99	7,99	Conrad Electronics

	Gesamtbetrag der Bestellung				38,88

Quellcode

Der Quellcode für die Programmierung des Arduino-Boards ist anliegend und beinhaltet das komplette Programm für die ordnungsgemäße Umsetzung:

//////////////////////////////////////////////////////////////////////
//                                                                  //
// Programm: Tischleuchte mit Helligkeitssensor                     //
//                                                                  //
// Ablauf im Programm: Die Werte des Sensors werden eingelesen.     //
// Ab einem bestimmten Grenzwert (On) wird der LED-Streifen         //
// eingeschaltet und über den Sensor die Helligkeit geregelt.       //
// Unterschreitet der Wert des Sensors einen bestimmten Grenzwert   //
// (Off), wird der LED-Streifen wieder ausgeschaltet.               //
// Zum Überprüfen der Sensorwerte und der dazugehörigen             //
// ausgesendeten Signale an die Lampe können diese im seriellen     //
// Monitor angeschaut werden.                                       //
//                                                                  //
// Autoren: Franziska Koch, Thorsten Solzbach, Martin Böhner        //
// Letzte Aktualiesierung: 29.12.17                                 //
//                                                                  //
//////////////////////////////////////////////////////////////////////

/*

zum Betrieb wird die Adafruit NeoPixel library benötigt.
Diese kann unter folgendem Link heruntergeladen und anhand der ebenfalls
dort verfügbaren Anleitung eingefügt werden kann:

https://github.com/adafruit/Adafruit_NeoPixel

 */


// LED-Streifen

#include <Adafruit_NeoPixel.h>  // Bibliothek für LED-Strp einfügen
#define PIN          4          // Steuerpin des LED-Strp definieren (wegen der Bibliothek mit #define
#define NUMPIXELS   60          // Anzahl der Pixel/LEDs die ich ansteuern möchte
Adafruit_NeoPixel leds = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); // string mit den nötigen Infos für die NeoPixel-Bibliothek
// Name des strings; die Bibliothek; Pixelzahl, Steuerpin, Art des NeoPixel stripe



// Lichtwiderstand

int sensorPin = A0;     // analogen Eingangspin des Sensors auswählen
int sensorvalue = 0;    // Variabel für den eingelesenen Sensorwert



// Allgemein

int On = 300;           // Grenze, wann die LED´s eingeschaltet werden
int brightness = 0;     // Variabel für den umgerechneten Sensorwert
int delayval = 200;     // Wartezeit zwischen den Abtastsequenzen (in ms)


void setup() {
  Serial.begin(9600);   // Beginn im Seriellen Monitor
  leds.begin();         // Initialisierung der Bibliothek
}



void loop() {
  // Einlesen der Sensordaten
  sensorvalue = analogRead(sensorPin);



  // LED-Streifen ab Grenzwet An einschalten
  if (sensorvalue >= On)
  {
    // Umrechnen der Sensordaten
    brightness = (sensorvalue - On) / (4*5); //analogRead geht von 0 bis 1023(aber nur der Bereich ab "On" ist relevant), analogWrite von 0 bis 255
    //--> also durch 4 teilen. Da der laptop aber nicht so viel power zur verfügung stellt, muss durch 20 geteilt werden --> geringere max Helligkeit

    //Daten für jeden Pixel speichern
    for (int i = 0; i < NUMPIXELS; i++)
    {
      // leds.Color kann RGB-Werte von 0,0,0 bis 255,255,255
      leds.setPixelColor(i, leds.Color(brightness, brightness, brightness)); // gleiche Werte für alle Pixel speichern
    }

    // Informationen an die Pixel senden und kurz warten
    leds.show();
    delay(delayval);
  }

  else
  {
    for (int i = 0; i < NUMPIXELS; i++)
    {
      // pixels.Color kann RGB-Werte von 0,0,0 bis 255,255,255
      leds.setPixelColor(i, leds.Color(0, 0, 0)); // alle auf Null setzen
    }

    // Informationen an die Pixel senden und kurz warten
    leds.show();
    delay(delayval);
  }


  // Überprüfen, welche Daten vom Sensor kommen und verarbeitet an den LED-Streifen gesendet werden
  Serial.print("Rohwert Lichtwiderstand: "); //sendet Daten an PC
  Serial.print(sensorvalue, DEC);
  Serial.print(", Helligkeit (Farbwert): ");
  Serial.println(brightness);              //...ln -> neue Zeile nach dieser Ausgabe
  
}

Ergebnis

Das Ergebnis aus der eigenständig definierten Aufgabe ist sehr zufriedenstellend. Die Anforderungen an das Projekt wurden erfüllt und die Umsetzung verlief nahezu reibungslos. Für das weitere Verständnis wurde ein Video auf Youtube hochgeladen, dieses befindet sich unter dem Kapitel Youtube-Video am Ende dieses Wiki-Artikels. Auf alle wesentlichen Inhalte und Funktionen wird in diesem Video eingegangen.

Zusammenfassung

Das GET-Fachpraktikum stellt unter anderem die Aufgabe ein Projekt in einer Gruppenarbeit mit 2-3 Teilnehmern in Eigenarbeit umzusetzen. Die Projektgruppe 20, hat sich dazu eine eigene Aufgabe gestellt, welche alle Anforderungen an das Praktikum erfüllt hat. Dieses wurde ausführlich mit dem betreuenden Dozenten Herrn Prof. Dr.-Ing. Mirek Göbel abgestimmt. Die Projektaufgabe besteht darin eine autonome Tischlampe mit dem Arduino-Board zu realisieren. Der Einstieg in die Projektaufgabe erfolgte mit dem Aufstellen eines morphologischen Kastens, welcher für die Findung der optimalen Lösungsvariante eingesetzt wurde. Mit dieser ingenieurmäßigen Methode zur Lösungsfindung, wurden die oben genannten Parameter für das Umsetzen der Projektaufgabe festgehalten.

Mit diesen gewonnenen Erkenntnissen, wurde die Bestellliste angefertigt. Die Inhalte daraus wurden an den betreuenden Dozenten weitergegeben, so dass die benötigten Artikel einige Zeit später geliefert wurden. Nachdem Erhalt der Bauteile wurden diese noch einmal Vermessen, um Maße aber auch ggf. Schwierigkeiten bei dem weiteren Verlauf des Zusammenbaus aufzuzeigen. Anschließend konnten die Zeichnungen für das Fertigen der Gehäusebauteile aus Holz angelegt werden. Nach dem Fertigstellen der Holzbauteile konnte, diese zusammengebaut und mit den elektrischen Komponenten verknüpft werden. Somit musste nur noch das Arduino-Board mit dem Programm für diese Aufgabenstellung versehen werden. Nach der Fertigstellung des Programmes, musste die autonome Tischlampe ausführlich getestet werden, so dass diese auch die Anforderungen der Aufgabenstellung erfüllt. Dazu mussten noch einige Parameter im Programm angepasst werden. Abschließend zu diesem Projekt wurde ein Video über die autonome Tischlampe erstellt und auf der Plattform Youtube hochgeladen. Demnach sind die Anforderungen der Projektaufgabe erfüllt.

Ausblick

Durch die gewonnen Erkenntnisse und die transparente Gestaltung der Ausführung des Projektes auf dieser Wiki-Plattform, können andere Studenten oder interessierte Personen dieses Projekt ohne Probleme nachbauen. Der Leitfaden und die benötigten Bauteile befinden sich in diesem Artikel. Die Umsetzung dieses Projektes erfolgte an einem kleinen Anwendungsbeispiel der Tischlampe. Diese kann selbstverständlich erweitert werden, so dass nicht nur ein Arbeitsbereich eine autonome Beleuchtung erfährt, sondern auch Räume, Hallenbereiche oder ganze Unternehmenskomplexe. Dies kann als eine vorbeugende Maßnahme der Gefahrenentwicklung in unterschiedliche Anwendungsbereiche eingebunden werden. Konstante Beleuchtung sorgt auch in Industriehallen für gleichbleibende Helligkeit, so dass die Fertigungsqualität durch solch eine Maßnahme eine Standardisierung erfahren kann. Des Weiteren kann die Tischlampe um ein Potentiometer ergänzt werden, über den der Grenzwert für den Einschaltmoment festgelegt wird.

Weiterführende Links

https://www.arduino.cc/ | Grundlage und Syntax-Übersicht für den Arduino
https://github.com/adafruit/Adafruit_NeoPixel | Programmierungshilfe für den Mikrocontroller Arduino

Unterlagen

Gesamtaufbau der autonomen Tischleuchte

Datei:Autonome Tischlampe Gesamtaufbau.PDF

Einzelteilzeichnung 1

Datei:Autonome Tischlampe Einzelteilzeichnungen 1.PDF

Einzelteilzeichnung 2

Datei:Autonome Tischlampe Einzelteilzeichnungen 2.PDF

Einzelteilzeichnung 3

Datei:Autonome Tischlampe Einzelteilzeichnungen 3.PDF

YouTube-Video

Das Video ist unter folgendem Link verfügbar: https://www.youtube.com/watch?v=7KtaXvUK674

Für die Erstellung des Videos wurde folgendes Programm verwendet:

Windows Movie Maker

Literaturverzeichnis

↑ Eigenes Foto
↑ Eigener morphologischer Kasten über die Lösungsfindung für das Projekt 20
↑ Eigene Skizze Variante 1
↑ Eigene Skizze Variante 2
↑ Eigene Skizze Variante 3
↑ Eigene Skizze Variante 4
↑ Eigene Skizze Variante 5
↑ Arduino Verdrahtungsskizze
↑ Benötigte Werkzeugliste
↑ Bestellliste für die benötigten Teile der Projektgruppe 20

Verwendete Hilfsmittel

Arduino 1.8.5
SolidWorks | Student Edition 2017 - 2018
Windows Snipping Tool

→ zurück zum Hauptartikel: Fachpraktikum Elektrotechnik & Angewandte Elektrotechnik

[1] Eigenes Foto

[2] Eigener morphologischer Kasten über die Lösungsfindung für das Projekt 20

[3] Eigene Skizze Variante 1

[4] Eigene Skizze Variante 2

[5] Eigene Skizze Variante 3

[6] Eigene Skizze Variante 4

[7] Eigene Skizze Variante 5

[8] Arduino Verdrahtungsskizze

[9] Benötigte Werkzeugliste

[10] Bestellliste für die benötigten Teile der Projektgruppe 20

[1]

[2]

[3]

[4]

[5]

[6]

[7]

[8]

[9]

[10]

Projekt 20: Autonome Tischlampe

Inhaltsverzeichnis