Farbsortiermaschine: Unterschied zwischen den Versionen

Version vom 18. Januar 2021, 20:52 Uhr

Farbsortiermaschine Messestand (Peppiges Bild)

Autoren: Franziska Troja, Florian Leben
Gruppe: 2.6
Betreuer: Prof. Dr. Mirek Göbel

→ zurück zur Übersicht: WS 20/21: Fachpraktikum Elektrotechnik (MTR)

Einleitung

Dieser Artikel beschreibt die Realisierung einer Farbsortiermaschine mit der Steuerung über einen Arduino. Dieser soll Schüttgut nach Farbe sortieren, sowie nicht definierbares Gut ausschleusen. Zudem erfolgt eine Zählung der verschiedenen Farben, sowie das Anzeigen der mit dem Farbsensor bestimmten Farbe über eine RGB LED.
Ziel des Projektes im GET-Fachpraktikum im 5. Semester des Studiengangs Mechatronik ist es, ein mechatronisches System zu bauen und in Betrieb zu nehmen. Abschließend wird das Projekt im Rahmen einer digitalen Messe vorgestellt. In dem Projekt werden alle drei wesentlichen Disziplinen des Studiengangs benötigt: die mechanische Konstruktion der Anlage, die elektrische Funktionsfähigkeit, sowie die Programmierung eines Mikrocontrollers.

Anforderungen

Für das Projektes wurden die folgenden Anforderungen ausgearbeitet:

Zuverlässige Vereinzelung des Schüttguts.
Definieren des Farbspektrums und der Toleranzbereiche.
Zuverlässige und wiederholbare Genauigkeit bei den Messungen.
Abschirmung von Fremdlicht für eine genauere Messung.
Zählung der gesamten Anzahl des Schüttguts.
Zählung der Anzahl jeder Farbe.
Anzeigen der gemessenen Farbe per RGB-LED.
Ausschleusung von Schüttgut, welches außerhalb des Toleranzbereiches fällt.

Funktionaler Systementwurf/Technischer Systementwurf

Das System besteht aus verschiedenen Komponenten. Das Schüttgut, welches sich in einem Vorratsbehälter befindet, wird vereinzelt und dann der Farberkennung übergeben. Zur Erfassung der Farbe wird ein Farbsensor des Typs TCS34725 eingesetzt. Die dadurch ermittelten Daten werden von einem Mikrocontroller verarbeitet. Anschließend wird das Gut mit einer Sortieranlage dem passenden Behälter der jeweiligen Farbe zugeführt. Optional kann das System durch eine RGB LED, welche die gemessene Farbe anzeigt, sowie durch einen RFID-Sensor erweitert werden, der eine Freischaltung der Farbsortiermaschine nur mit einer passenden Chipkarte ermöglicht.

Komponentenspezifikation

Arduino UNO R3

In diesem Projekt werden zwei Arduino UNO Boards verwendet, die auf einem Atmel-AVR-Mikrocontroller basieren. Die Boards sind mit der SMD-Bauweise realisiert und können entweder über eine USB-Schnittstelle (5V) oder eine externe Spannungsquelle (7-12V) versorgt werden. Sie takten zudem mit einer Frequenz von 16 MHz. Der Arduino verfügt über 14 digitale I/Os und über sechs analoge Eingänge. An den Arduino können an die zur Verfügung gestellten I/O Pins verschiedene Aktoren und Sensoren angeschlossen werden. Es kann außerdem mit einem I²C-Bus kommuniziert werden.

Micro-Servomotor SG90

Der Servomotor besteht aus einem Elektromotor und einem Rotationssensor. Der Motor kann mit einer Spannung zwischen 4,8V bis 6V betrieben werden. Durch den Arduino wird er mit einer Spannung von ungefähr 5V betrieben, so dass er sich mit der Geschwindigkeit von 60° pro 0,3sec bewegt.

Schrittmotor ULN2003 5V

Als weiteren Antrieb werden zwei Schrittmotoren verwendet. Die Motoren verfügen über vier Spulen, die einpolig mit den 5V des Arduinos betrieben werden. Der Schrittmotor kann nicht direkt mit dem Arduino verbunden werden, da die Pins zu wenig Strom liefern. Dem Schrittmotor muss deswegen eine Treiberplatine vorgeschaltet werden, welche separat an die Versorgungsspannung angeschlossen wird. Er kann 2048 Schritte mit hoher Präzision anfahren.

Farbsensor TCS34725 RGB-Sensor

Der RGB-Farbsensor der Firma Adafruit verfügt über einen Infrarotfilter und eine LED, die auch per Schaltung ausgeschaltet werden kann. Der Farbsensor besteht aus vier einzelnen Sensoren, die einen Rot-, Grün-, Blau- und Lichtstärkenwert zurückgeben. Der IR-Filter sorgt dafür, dass das IR-Spektrum minimiert wird und somit eine genauere Farbmessung durchgeführt werden kann. Der Farbsensor kommuniziert über den I²C-Bus.

RGB-LED

Die RGB-LED besteht aus vier Leitungen. Eine Leitung ist jeweils für eine der Farben (Rot, Grün und Blau) und die längste Leitung für die gemeinsame Kathode, dementsprechend werden die anderen Leitungen über die Spannung versorgt. Im Inneren besteht die LED aus drei einzeln ansteuerbaren LEDs. Die RGB-LED kann verschiedene Farben darstellen, indem die drei Grundfarben Rot, Grün und Blau gemischt werden. Es kann zudem die Intensität der Farbstärke variiert werden. Die Farbwerte können Werte zwischen 0 und 255 annehmen. Diese LED wird dazu verwendet, um den Betriebszustand der Farbsortiermaschine anzuzeigen.

LCD-Display

Als Anzeige wird ein LCD-Display mit blauer Hintergrundbeleuchtung verwendet, um die Aktuell gemessene Farbe anzuzeigen, sowie die Anzahl der gemessenen Skittles pro Farbe anzuzeigen. Dieses kann jeweils 16 Zeichen auf zwei Zeilen anzeigen und wird über den I²C-Bus angesteuert.

Umsetzung (HW/SW)

Hardware

Die Farbsortiermaschine ist in drei Bereiche unterteilt: die Zuführung des Schüttguts, in diesem Fall Skittles, der Farbmessung und der Sortierung. Der Aufbau orientiert sich an der zuvor erstellten Skizze. Die für das Projekt benötigten mechanischen Bauteile wurden im 3D-Druck verfahren hergestellt.

Versuchsaufbau
Zuführung
Grundaufbau
Schwenkarm

Der Aufbau der Maschine erfolgte zu Testzwecken vorläufig mittels einfacher 3D gedruckter Standbeine und einem einfachen Trichter als Zuführung. Nach den erfolgreichen Testversuchen wurde mit der Realisierung der Zuführung begonnen.
Da das Prinzip mit dem vorhandenen Drehteller für die Farbmessung gut funktionierte, wurde diese für die Zuführung erneut verwendet und den neuen Anforderungen entsprechend angepasst. Die Zuführung der Skittles erfolgt als Schüttgut über eine Öffnung an der Oberseite der Maschine. Darunter befindet eine Art Trichter, an dem eine schräg angeordnete Scheibe mit 12 Löchern montiert ist. Diese rotierende Scheibe wird mit Hilfe eines Schrittmotors betrieben und führt die Skittles nacheinander einem Auswurfloch zu. Zur Verbindung der beiden Maschinenabschnitte wurde ein Rohr mit Sichtfenster zu konstruiert, welches zeitgleich als Pufferspeicher zwischen der Zuführung und der nachfolgenden Farbmessung dient.
Das Rohr endet auf einem Drehteller, einer weiteren Scheibe mit 12 Löchern. Diese Scheibe wird wie auch die Zuführung durch einen Schrittmotor angetrieben und nimmt immer ein Skittle aus dem Pufferspeicher auf. Das Skittle wird dann mit der Scheibe Schrittweise weiter getaktet, bis es unter dem Farbsensor positioniert ist. Der Farbsensor ist mit einer Halterung an dem Drehteller befestigt und über dem Skittle positioniert. Die Scheibe taktet anschließend weiter zur nächsten Position. Bei dieser Position befindet sich ein Loch unter dem Drehteller, wodurch das Skittle dann ausgeschleust wird. Das Skittle fällt dann durch das Loch direkt in den Trichterförmigen Schwenkarm. Dieser Arm kann sechs unterschiedlichen Positionen mithilfe eines Servomotors anfahren. Das Skittle wird dann über eine Schiene zu dem jeweiligen Behälter weitergeleitet. Diese Behälter sind einzeln zu entnehmen und können so sehr einfach entleert werden. Der sechste Behälter ist für den Ausschuss gedacht und die anderen fünf für die jeweilige Farbe (rot, orange, gelb, grün, lila).
Die Anzahl der Sortierten Skittles, sowie die aktuell gemessene Farbe wird auf dem Display angezeigt. Der Betriebszustand der Farbsortiermaschine wird über die RGB-LED angezeigt. Da beim erste Arduino Uno für die Farbmessung und Sortierung der Skittles nicht mehr genügend freie Anschlüsse vorhanden waren, wurde eine zweiter Arduino Uno für die Zuführung verwendet, um diese anzusteuern.
Nachdem die Abmaße durch die vorhandenen Kernelemente der Maschine feststanden, wurde das Gehäuse der Maschine geplant. Der Korpus der Farbsortiermaschine wurde aus Holzplatten zugeschnitten, welche anschließend mit Dekorfolie beklebt wurden, um ein einheitliches Maschinendesign zu erhalten. Anschließend wurde mit der Montage der einzelnen Komponenten begonnen. Nachdem die Maschine mechanisch fertig gestellt war, wurde die Elektronik eingebaut und angeschlossen. Danach wurden die Komponenten der Maschine noch einmal einzeln angesteuert, um den richtigen Anschluss und die Funktionsfähigkeit der Komponenten sicherzustellen.

Skittles Rutsche in der Slicer Vorschau
Schaltungsaufbau Farbmessung
Schaltungsaufbau Zuführung
Realisierung des Schaltungsaufbaus

Software

Die Software wurde mit Arduino IDE realisiert. Damit die Zuführung der Skittles autark laufen kann, wurden zwei Arduinos verwendet, so dass auch zwei unterschiedliche Programme notwendig waren.
Für die Ansteuerung und dem Auslesen der Sensoren und Aktoren werden bestimmte Bibliotheken benötigt, die vorher installiert und in den Programmen eingebunden werden müssen.

Header und benötigte Bibliotheken

Zu Beginn wurde am Anfang des Programms ein Header erstellt, damit die grundlegenden Informationen zum Programm kenntlich gemacht sind. So erhält man Informationen über das vorliegende Progamm und dessen Funktion. Im Anschluss wurde die Pinbelegung übersichtlich festgehalten, damit beim weiteren Programmieren schnell ersichtlich ist, welcher Pin welche Funktion erfüllt. Die für die verschiedenen Komponenten benötigten Bibliotheken wurden im darauffolgenden Programmblock eingebunden.

//==================================================================================
// GET-Fachpraktikum 
// Studiengang: Mechatronik 
// 5.Semester
// Florian Leben, Franziska Troja
//----------------------------------------------------------------------------------
// Title: Farbsortiermaschine_LebenTroja
// Funktion: Sortierung der Skittles nach ihren Farben in verschiedene Behälter


/*
Pinbelegung:  

| Farbsensor    | Schrittmotor UNTEN  | Servo        | LCD Display       | RGB LED         |
|:-------------:|:-------------------:|:------------:|:-----------------:|:---------------:|
| A4    SDA     | Pin 13  IN 1        | Pin 10       | A4      SDA       | A1      Red     |
| A5    SCL     | Pin  9  IN 2        |              | A5      SCL       | A0      Green   |
| VDD   +5V     | Pin 12  IN 3        |              | VDD     +5V       | A2      Blue    |
| GND   GND     | Pin  8  IN 4        |              | GND     GND       |                 |


*/

// benötigte Bibliotheken
#include <Wire.h> 
#include <LiquidCrystal_I2C.h> 
#include "Adafruit_TCS34725.h"
#include <Servo.h>
#include <Stepper.h>

Initialisierung

Nachdem einbinden der Bibliotheken wurden die verschiedenen Aktuatoren, Sensoren und Anzeigeelemente initialisiert. Zudem werden den verschiedenen Bauteilen die Namen und Anschlusspins für das spätere Programm zugewiesen, sowie die Counter für die verschiedenen Farben initialisiert.

// LCD-Display initialisieren
LiquidCrystal_I2C lcd(0x27, 16, 2); 

// Farbsensor initialisieren
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_101MS, TCS34725_GAIN_1X);

// Servo initialisieren
Servo servo;

// Schrittmotor initialisieren
int SPU = 2048;
Stepper MotorUnten(SPU, 12, 8, 13, 9);

// Pins für RGB
#define rot A1
#define gruen A0
#define blau A2

// Zuweisung für Counter
int Gelb = 0;
int Orange = 0;
int Rot = 0;
int Gruen = 0;
int Lila = 0;
int Fail = 0;
String Farbe;

Setup

Das Setup wird bei jedem Neustart oder Reset des Arduinos aufgerufen. In der Konfiguration wird das LCD-Display gestartet, sowie die Hintergrundbeleuchtung eingeschaltet. Ebenso werden die Pinmodi initialisiert, wodurch festgelegt wird, ob ein Pin als Eingang oder Ausgang verwendet wird. Außerdem wird dem Servo der Pin für das Steuerungssignal und dem Schrittmotor die Geschwindigkeit, welche in Umdrehung pro Minute angegeben wird, zugeordnet.

  
void setup() 
{
  // LCD Display
  lcd.init(); 
  lcd.backlight();  

  // Deklarierung der analogen Eingänge als Ausgänge 
  pinMode(rot, OUTPUT);
  pinMode(gruen, OUTPUT);
  pinMode(blau, OUTPUT);

  // Festlegung des Pins für den Sevo
  servo.attach(10);

  // Geschwindigkeit des unteren Schrittmotors
  MotorUnten.setSpeed(7);
}

Hauptprogramm

Auf dem einen Arduino wurde das Hauptprogramm umgesetzt, dies kann in drei Bereichen eingeteilt werden. In dem ersten Bereich wird zunächst die Messung durch den Farbsensor durchgeführt. Der Farbsensor liefert vier Werte zurück, jeweils einen Wert für rot, grün, blau und einen Rohwert der Farbe. Da die Werte für RGB nicht sehr aussagekräftig sind, wird zunächst der Durchschnitt der RGB-Werte berechnet, so dass sich die RGB-Werte nun um eins bewegen. Damit kann dann ein Rückschluss auf die Farbe gezogen werden. Wenn beispielsweise der Wert für rot größer eins ist, ist der Rotanteil in der Farbe sehr hoch, so dass dies wahrscheinlich dann Farben, wie rot, lila oder rosa sein könnte. Die RGB-Werte und der Rohwert werden mit den vorher festgelegten Bereichen für die einzelnen Farben verglichen. Abhängig von der Farbe wird dem Servo die Position zugeordnet und der Counter der jeweiligen Farbe wird um eins hochgezählt. Zusätzlich wird die RGB-LED entsprechend der Farbe angesteuert. Im Anschluss an den Sortiervorgang wird die Anzahl der sortierten Skittles sowie die Farbe des Skittles auf dem Display ausgegeben. Am Ende des Vorgangs wird der Drehteller eine Position weiter getaktet, sodass sich das nächste Skittle unter dem Farbsensor befindet.

void schrittmotorUnten()
{
  // Schrittmotor um eine Position weitertakten lassen
  MotorUnten.step(170);
}

Programm Zuführung

Auf dem zweiten Arduino wird das Programm für die Zuführung ausgeführt. Der Schrittmotor der Zuführung sollte sich kontinuierlich drehen, damit eine verlässliche Zuführung des Magazins gewährleistet ist, wurde dieses auf einem separaten Arduino ausgeführt. Es könnte sonst zu deutlichen Verzögerungen beim Sortiervorgang kommen, da der Arduino nur ein Schritt nach dem anderen abarbeiten kann und somit nahezu durchgehend mit der Zuführung beschäftigt wäre.

Komponententest

Bevor mit dem Bau der Farbsortiermaschine begonnen wurde, wurden die einzelnen Komponenten separat an den Arduino angeschlossen, mit Testprogrammen angesteuert und auf Funktion getestet.
Im Folgenden sind Beschreibungen der durchgeführten Tests und die dazugehörigen Programme für die einzelnen Komponenten in der Testphase zu finden:

Servopositionierungen

Positionierung des Servos für die Behälter

//===========================================================================================
// Florian Leben, Franziska Troja
//-------------------------------------------------------------------------------------------
// Title: Positionen_Servo
// Funktion: Einstellung der Positionen des Servos für die Behälter der Farben

// benötigte Bibliothek
#include <Servo.h>

Servo servo;

void setup() 
{
  servo.attach(10); // Pin 10 für Servo
}

void loop() 
{
  servo.write(155); //Position 155 ansteuern
}

Zum Ansteuern des Servos muss zunächst die Bibliothek Servo.h eingebunden werden. Anschließend wurden Testweise verschiedene Positionen angesteuert um die Arbeitsgeschwindigkeit und Positioniergenauigkeit des Servos zu testen. Nach dem die Wiederholgenauigkeit des Servos zufriedenstellend war, wurden die Positionen für die Zuordnung der einzelnen Farben festgelegt.

Test des I²C-Displays

Darstellung von Text auf dem Display

//==================================================================================
// Florian Leben; Franziska Troja
//----------------------------------------------------------------------------------
// Title: I2C_Display_testen
// Funktion: Ausprobieren des LCD-Displays in der Ansteuerung der beiden Zeilen

// benötigte Bibliotheken
#include <Wire.h> 
#include <LiquidCrystal_I2C.h> 

// Initialisierung des Displays
LiquidCrystal_I2C lcd(0x27, 16, 2);


void setup() 
{
  lcd.init(); 
  lcd.backlight();
}

void loop() 
{
  lcd.setCursor(0, 0);  // Position des Cursors, beginnt beim ersten Zeichen in oberen Zeile
  lcd.print("Oben");    // beschreibt ab der Position 0,0 das Wort "Oben"
  delay (2000);         // zwei Sekunden warten
  lcd.clear();          // Display wird gelöscht
  lcd.setCursor(5, 1);  // Position des Cursors, beginnt beim fünften Zeichen in unteren Zeile
  lcd.print("Unten");   // beschreibt ab der Position 5,1 das Wort "Unten"
  delay (2000);         //Zwei Sekunden warten
  lcd.clear();          //Display wird gelöscht
}

Das Display wird über den I²C Bus angesteuert. Die Bus-Adresse des Displays wurde zunächst mit dem I²C Scanner überprüft, bevor die benötigten Bibliotheken Wire.h und LiquidCrystal_I2C.h eingebunden wurden. Anschließend wurde das Display initialisiert und es wurden verschiedene Positionen des Displays angesteuert und mit Text beschrieben und im Anschluss wieder gelöscht.

Test des Farbsensors

Farbsensor TCS34725 ausprobieren

//==============================================================================================
// Florian Leben; Franziska Troja
//----------------------------------------------------------------------------------------------
// Title: Test_Farbsensor
// Funktion: Testen des Farbsensors mit Ausgabe der gemessenen Farbe auf dem seriellen Monitor

// benötigte Bibliotheken
#include "Adafruit_TCS34725.h"
#include <Wire.h>


Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_1X);


void setup() 
{
  Serial.begin(9600);

 
  if (tcs.begin()) 
  {
    // Alles ok
    Serial.println("Sensor gefunden");
  } 
  else 
  {
    // Kein Sensor gefunden. Programm wird gestoppt
    Serial.println("TCS34725 nicht gefunden ... Ablauf gestoppt!");
    while (1); // Halt!
  }
}

void loop() 
{
  uint16_t clearcol, rot, gruen, blau;
  float durchschnitt, r, g, b;
  delay(100); // Farbmessung dauert c. 50ms 
  tcs.getRawData(&rot, &gruen, &blau, &clearcol);
   
  // Durchschnitt von RGB ermitteln
  durchschnitt = (rot + gruen + blau)/3;
  
  // Farbwerte durch Durchschnitt
  r = rot / durchschnitt;
  g = gruen / durchschnitt;
  b = blau / durchschnitt;  
  
  
  Serial.print("Wellenlänge: " + String(clearcol));
  Serial.print(", Rot: " + String(r));
  Serial.print(", Grün: " + String(g));
  Serial.print(", Blau: " + String(b));



  //Farberkennung
  
  // Orange
  if ((clearcol > 40) && (r > 1.4) && (g < 0.9) && (b < 0.7)) 
  {
    Serial.print("\tORANGE");
    }  
  
  // Rot
  else if ((r > 1.4) && (g < 0.9) && (b < 0.9)) 
  {
    Serial.print("\tROT");
    }
  
  // Grün
  else if ((r < 0.95) && (g > 1.4) && (b < 0.9)) 
  {
    Serial.print("\tGRUEN");
    }
 
  // Lila
  else if ((r > 1.1) && (g < 1.1) && (b < 1.1)) 
  {
    Serial.print("\tLILA");
    }
  
  // Gelb
  else if ((r > 1.15) && (g > 1.15) && (b < 0.7)) 
  {
    Serial.print("\tGELB");
   }
 
  // Ausschuss
  else 
  {
    Serial.print("\tNICHT ERKANNT"); 
   }


  Serial.println("");
  
  delay(100);
}

Der Farbsensor wird wie auch das Display über den I²C Bus angesteuert. Die Bus-Adresse des Farbsensors wurde zunächst auch mit dem I²C Scanner überprüft. Die beiden Bus-Adressen unterschieden sich, so dass die Bus-Adressen beibehalten und beide Komponenten über einen I²C Bus angesteuert werden konnten.

Zuerst wurde jede Komponente einzeln überprüft. Anschließend wurden alle Komponenten zusammen getestet, wobei eine Fehlfunktion der RGB-LED auftrat, die mit der Einbindung der Servo Bibliothek zusammenhängt. Im Verlaufe des Projektes konnte dies dann über die Ansteuerung der RGB-LED über die analogen Eingänge, die dann als Ausgänge verwendet wurden, gelöst werden. Die Schwierigkeit hierbei besteht darin, dass die LED so nur über HIGH oder LOW an den einzelnen Anschlüssen angesteuert werden kann und nicht über Stufen (0-255), so dass die Helligkeit der einzelnen LED-Farbe nicht variiert werden kann.

Zusammenfassung

Ergebnis

Insgesamt sind wir stolz auf das Projektergebnis, denn das Projekt "Farbsortiermaschine" konnte insgesamt gut umgesetzt worden. Dies kann man sowohl auf den Bildern als auch in dem Video erkennen.
Die Anforderungen, welche zu Beginn bei der Planung des Projektes festgelegt wurden, konnten erreicht werden. Die Sortierung der Skittles funktioniert wiederholgenau und nahezu fehlerfrei. Durch die Automatische Zuführung und die Optimierung der einzelnen Abläufe konnte sowohl die Sortiergeschwindigkeit als auch die Genauigkeit der Farbsortiermaschine im Laufe des Projektes gesteigert werden.

Durch eine enge Zusammenarbeit der Projektpartner konnten die anfangs festgelegten Ziele zu den vereinbarten Zeitpunkten erreicht werden. Trotz der Einschränkungen aufgrund der Corona-Pandemie wurden regelmäßig Besprechungen zum Fortschritt des Projektes abgehalten, welche größtenteils online durchgeführt wurden. So waren beide Projektpartner stets auf dem gleichen Kenntnisstand, auch wenn der persönliche direkte Kontakt eingeschränkt war. Bei auftretenden Problemen konnten diese so schnell gemeinsam besprochen und gelöst werden.

Als Weiterentwicklung könnte eine Positionsabfrage des Drehtellers realisiert werden, da es vereinzelt dazu kommt, dass ein Skittle den Drehteller zweitweise blockiert und es so zu einem Schrittverlust beim Schrittmotor kommt. Daraufhin werden die folgenden Skittles nicht mehr exakt unter dem Farbsensor platziert, so dass es zu fehlerhaften Messungen kommen kann. Zudem ist die Anzeige der gemessenen Farbe der RGB-LED ausbaufähig, da diese über die analogen Anschlüsse des Arduinos gesteuert werden und die Anzeige der einzelnen Farben demzufolge nicht in Stufen dargestellt werden kann. So können die verschiedenen Farben nicht genau gemischt und dargestellt werden. Die optional geplante Erweiterung der Farbsortiermaschine mittels eines RFID-Sensor konnte aufgrund der zur Verfügung stehenden Zeit bis zur Projektabgabe nicht realisiert werden. Zusätzlich könnte auch noch eine automatische Beendigung des Sortiervorgangs implementiert werden, sobald der Vorratsbehälter leer ist.

Lessons Learned

Zum einen konnte durch das Projekt verschiedene Studieninhalte gefestigt und praktische Bezüge dazu hergestellt werden. Dazu zählen:

Planung eines Projektes unter Verwendung geeigneter Projektmanagementmethoden
Konstruktion von Bauteilen in einem CAD-Programm
Programmierung von Microcontrollern
Auswahl geeigneter Sensoren und deren Programmierung

Da in der Realität nicht alles so funktioniert wie in der Theorie, traten Komplikationen auf:

Die Kompatibilität der Komponenten über die ursprünglich geplante Beschaltung hätte eher überprüft werden müssen.
Die Programmierung in Simulink war nicht möglich, da eine Bibliothek zur Auslesung des Farbsensors fehlte und die Entwicklung einer eigenen Bibliothek den Zeitrahmen ausgelastet hätte.
Die Termingrenzen früher setzen, um noch Zeit, unter anderem für die Dokumentation oder auftretende Schwierigkeiten, am Ende zur Verfügung zu haben.

Projektunterlagen

Projektplan

Projektdurchführung

Bei der Projektdurchführung wurde der zu Beginn des Projektes erstellte Projektplan verfolgt. Es wurde ein Ablaufplan und Zeitfenster für die verschiedenen Arbeitsschritte festgelegt. Die Beschaffung der Bauteile schloss sich an die Planung an und es wurden erste Teile der Dokumentation erarbeitet. Nachdem alle Bauteile beisammen waren, wurde mit der Realisierung von Hard- und Software begonnen. Vor der Montage der Farbsortiermaschine wurden umfangreiche Tests der einzelnen Komponenten durchgeführt. Im Anschluss wurde das Gesamtsystem getestet und optimiert. Am Schluss wurde die während der Realisierung des Projektes gesammelte Dokumentation zusammengeführt und im Rahmen des HSHL-Wiki-Artikels festgehalten.

SVN-Ordner

Direktlink zum SVN-Ordner: Projekt 102: Farbsortiermaschine

YouTube Video

Der Link zum Video der Farbsortiermaschine.

Weblinks

Datenblätter

Literatur

↑ Eigenes Dokument
↑ Eigenes Dokument
↑ Eigenes Dokument
↑ Eigenes Dokument
↑ https://www.funduinoshop.com/epages/78096195.sf/de_DE/?ObjectID=45510254
↑ Eigenes Dokument
↑ https://www.funduinoshop.com/epages/78096195.sf/de_DE/?ObjectID=54598480
↑ Eigenes Dokument
↑ Eigenes Dokument
↑ Eigenes Dokument
↑ Eigenes Dokument
↑ Eigenes Dokument