Farbsortiermaschine
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.
![](/wiki/images/thumb/6/67/FarbsortiermaschinePAP.png/600px-FarbsortiermaschinePAP.png)
Komponentenspezifikation
- Arduino UNO R3
![](/wiki/images/thumb/1/1a/Arduino_Board.jpeg/150px-Arduino_Board.jpeg)
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
![](/wiki/images/thumb/1/1e/Servomotor.jpeg/150px-Servomotor.jpeg)
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
![](/wiki/images/thumb/1/1f/Schrittmotor.png/150px-Schrittmotor.png)
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
![](/wiki/images/thumb/b/b6/RGB_Farbsensor.jpeg/150px-RGB_Farbsensor.jpeg)
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
![](/wiki/images/thumb/9/98/RGB-LED.png/150px-RGB-LED.png)
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
![](/wiki/images/thumb/5/5f/LCD_Display.jpeg/150px-LCD_Display.jpeg)
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.
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:
![](/wiki/images/thumb/6/6d/Positionierung_Servo.jpg/300px-Positionierung_Servo.jpg)
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.
![](/wiki/images/thumb/d/d4/Display_Test.jpg/350px-Display_Test.jpg)
Darstellung von Text auf dem Display
//================================================================================== // Florian Leben; Franziska Troja //---------------------------------------------------------------------------------- // Title: LCD_Display // 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.
![](/wiki/images/thumb/e/e2/Test_Farbsensor.jpg/400px-Test_Farbsensor.jpg)
Farbsensor TCS34725 ausprobieren
//============================================================================================== // Florian Leben; Franziska Troja //---------------------------------------------------------------------------------------------- // Title: Test_Farbsensor // Funktion: Testen des Farbsensors mit Ausgabe der gemessenen Farbe auf dem seriellen Monitor #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 an dieser Stelle einfrieren 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, sodass 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 man die LED nur über HIGH oder LOW an den einzelnen Anschlüssen ansteuern kann und nicht über Stufen (0-255), so dass die Helligkeit der einzelnen LED-Farbe nicht variiert werden kann.
Ergebnis
Zusammenfassung
Der Sortiervorgang soll automatisch beendet werden, sobald ein Sensor am Vorratsbehälter meldet, dass der Behälter leer ist.
Lessons Learned
Projektunterlagen
Projektplan
Projektdurchführung
YouTube Video
Weblinks
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
→ zurück zur Übersicht: WS 20/21: Fachpraktikum Elektrotechnik (MTR)