Farbsortiermaschine

Aus HSHL Mechatronik
Zur Navigation springen Zur Suche springen

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.
  • Ausschleusung von Schüttgut, welches außerhalb des Toleranzbereiches fällt.
  • Automatische Abschaltung, wenn Schüttgut leer.

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. Der Sortiervorgang soll automatisch beendet werden, sobald ein Sensor am Vorratsbehälter meldet, dass der Behälter leer ist. 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.

Systementwurf der Farbsortiermaschine (Skizze) [1]
PAP der Farbsortiermaschine [2]



















Komponentenspezifikation

  • Arduino UNO R3
Arduino UNO R3 [3]

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
Micro-Servomotor SG90 [4]

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
Schrittmotor [5]

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
TCS34725 [6]

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
RGB-LED [7]

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
16x2 LCD Display [8]

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

    Versuchsaufbau

  • Zuführung

    Zuführung

  • Grundaufbau

    Grundaufbau

  • Schwenkarm

    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

    Skittles Rutsche in der Slicer Vorschau

  • Schaltungsaufbau Farbmessung

    Schaltungsaufbau Farbmessung

  • Schaltungsaufbau Zuführung

    Schaltungsaufbau Zuführung

  • Realisierung des Schaltungsaufbaus

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

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:


Servopositionierung [9]

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 Displays [10]

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.


Ausgabe der Farben mit Farbsensor [11]

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

Lessons Learned

Projektunterlagen

Projektplan

Projektdurchführung

YouTube Video

Weblinks

Literatur

  1. ↑ Eigenes Dokument
  2. ↑ Eigenes Dokument
  3. ↑ Eigenes Dokument
  4. ↑ Eigenes Dokument
  5. ↑ https://www.funduinoshop.com/epages/78096195.sf/de_DE/?ObjectID=45510254
  6. ↑ Eigenes Dokument
  7. ↑ https://www.funduinoshop.com/epages/78096195.sf/de_DE/?ObjectID=54598480
  8. ↑ Eigenes Dokument
  9. ↑ Eigenes Dokument
  10. ↑ Eigenes Dokument
  11. ↑ Eigenes Dokument

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

Abgerufen von „https://wiki.hshl.de/wiki/index.php?title=Farbsortiermaschine&oldid=70115“