Bauen mit System

Aus HRW FabLab MediaWiki
Wechseln zu: Navigation, Suche
Bauen mit System

Final.jpg

Programmiersprache

C / C++

Software

Arduino IDE, Autodesk Inventor, TinkerCAD Cura

Hardware

HX711, Ultimaker 3, Wägezelle(Doppelbiegebalken)

Team

Xelia Mattick, Markus Meier, Felix Hajek

Grundsätzlich handelt es sich bei dem Projekt „Bauen mit System“ um ein Assistenzsystem für die Mitarbeiter, welche in der Rheinbabenwerkstatt Bauteile in festgelegter Reihenfolge zusammensetzen. Mittels Gewichts Sensorik unter einer Auflageplatte auf denen die Kisten mit Bauteilen platziert wird, sowie jeweils einer damit verbundenen LED Lampe, werden Orientierungshilfen für den Arbeitsablauf bereitgestellt. Die leuchtende LED zeigt an, welches Bauteil für den aktuellen Arbeitsschritt vorgesehen ist, sodass der Nutzende durch das System insbesondere kognitiv entlastet wird. Prinzipiell wird kontinuierlich, der durch das Herausnehmen des vorgegebenen Materials einhergehende Gewichtsverlust, der, der darauffolgenden Kiste zugehörigen LED Lampe signalisieren, aufzuleuchten und der zuletzt entnommenen, zu erlöschen. Damit soll die Produktivität gesteigert und die Fehlerrate vermindert werden.

Montierte Waage mit LED

Konzeptionierung[Bearbeiten]

Die Konstruktionsschritte für die Arbeiter der Diakonie sind vorgegeben, was mit dem Assistenten unterstützt werden soll. Durch eine konstant hohe Lautstärke innerhalb der Werkstatt schieden akustische Signale aus. Nach Gesprächen mit Beteiligten in der Diakonie selbst, manifestierte sich die Idee von Signallampen in Verbindung mit Gewichtssensoren um die nächsten Arbeitsschritte klarzustellen und (eventuell) zusätzlich vor geringen Bauteilbeständen in den jeweiligen Kästen zu warnen. Die finale Konzeptionierung des Systems erfolgte nach Rücksprache mit der Diakonie. Das System wird bewusst einfach gehalten, die Bauteile sollen widerstandsfähig sein und eine gute Wartbarkeit besitzen. Daher werden die Komponenten in einem robusten 3-D-Druck Case für den Einsatz in der Werkstatt 'verpackt'.

Komponenten (je Case)[Bearbeiten]

"Main"-Case mit verbautem Arduino

Der Arduino als Komponente ist einmalig und gilt nur für ein "Main" Case worin der Arduino verbaut wird. Für zusätzliche Cases wird kein weiterer Arduino benötigt.

Komponente Nutzung Preis
Arduino UNO Koordinierung der Waagen und LEDs 4,99€
HX711 Messung des Gewichtsunterschieds 9,99€
Wägezelle Gewichtsmessungsmedium bei HX711 inbegriffen
LED Signalisierung für Nutzer 1,99€
3D-Druck(s) der Auflageplatte Abstellfläche der Materialkisten von HRW übernommen

3-D-Druckmodelle[Bearbeiten]

Während der Entwicklung des Systems, wurde ein erster Prototyp der Auflageplatte bzw. des Cases für den Sensor, LED und Arduino, entworfen, welcher allerdings aufgrund eines fehlerhaften Designs verworfen und durch ein aktualisiertes (und finales) ersetzt wurde. Neben designtechnischen Mängeln, waren während der Entwicklung diverse Komplikationen bei der 3-D Modellierung aufgefallen. So gab es teilweise Schwierigkeiten Drucker zu verwenden welche aufgrund der Maße der Platten ein Minimum an Größe erforderten, da diese nicht funktionierten oder belegt waren (und 3-D Drucke benötigen viel Zeit). So verzögert sich je nach Verfügbarkeit der Teammitglieder die Weiterverarbeitung oder gar die Überprüfung, ob der Druck nicht fehlerhaft war um mehrere Tage. Die Fehlerquote der Drucks war zudem sehr hoch, sodass ein und derselbe Druck mehrfach in Auftrag gegeben werden musste bis dieser Erwartungen entsprach.

Erster Prototyp[Bearbeiten]

Der erste - und wie erwähnt fehlerbehaftete - Prototyp einer Waage-Box.

Erster Prototyp: Case Erster Prototyp: Auflage

Bei diesem ersten Prototypen wurden zwei LED Sockel, sowie ein physischer Reset-Knopf am Case vorgesehen. Durch ein kleines Loch auf der entgegengesetzten Seite sollte die Verkabelung nach innen geführt werden. Die Auflageplatte sowie das Case sollten durch das jeweils hervorstehende Verbindungsstück zusammen mit der Wiegezelle verschraubt werden (Verschraubungen vorliegend nicht visualisiert). Für die Signalisierung war von den LEDs eine für den aktuellen Arbeitsschritt, und eine für geringen Bestand angedacht. Der Reset-Knopf sollte den Nutzer die Möglichkeit geben, den Counter - für den geplanten Gamification-Aspekt - am Ende eines Durchlaufs zurückzusetzen. Allerdings wurden bei diesem Design das Gewicht von dem Sensor fehlerhaft gemessen, sodass uns keine andere Wahl blieb als den bisherigen Entwurf anzupassen, nachdem sich das Problem mit Sicherheit auf das Design des Cases zurückführen ließ. Neben essentiellen Veränderungen um korrekte Messungen des Gewichts zu gewährleisten, wurde die zusätzliche LED, welche für Warnungen über geringes Gewicht vorgesehen war, entfernt. Gleiches gilt für den Reset-Knopf, da der Ansatz von Gamification sich nicht in der Entwicklung einfinden konnte. Dieser neue Entwurf, entspricht dem finalen Prototypen.

Finaler Druck[Bearbeiten]

Der verbesserte Prototyp mit (vorliegend) modellierten Verschraubungsöffnungen für die Wiegezelle (Case und Auflage), sowie Gewichtsensor und Arduino UNO (jeweils nur Case).

Auflage Pic1.png Auflage Pic2.png Auflage Pic3.png

Für die neue Auflageplatte wurde das Verbindungsstück mehr im Zentrum der Platte angelegt, um mit dem ebenfalls (nach wie vor) zentral im Case platzierten Gewichtssensor verschraubt zu werden. Von der Oberseite der Platte werden zwei M2 Schrauben, welche für die von uns verwendete Wägezelle vorausgesetzt werden, da vorgebohrte Gewindevorrichtungen bereits vorliegen, mit der Wägezelle verschraubt. Darüber hinaus wurden für diese Verschraubungen einige Unterlegscheiben eingesetzt, damit die Auflage eine geringere Auflagefläche auf der Wägezelle einnimmt, sodass die Biegung der Zelle - und dadurch die Messung von Gewicht - gewährleitet werden kann.

Case Pic1.png Case Case Pic3.png

Für das Case, welches mittels einer mit einer Mutter befestigten M3 Schraube zusammen mit der Wägezelle verschraubt wurde, mussten zusätzlich der HX711 Sensor, als auch der Arduino UNO ebenfalls 'standardisierten' M2 Verschraubungen mit dem Case vereint werden. Neben den Verschraubungen mussten Steckplätze bei den jeweiligen Sensoren festgelötet und natürliche jegliche Verkabelungen durch das 'Main'-Case (Waage mit verbautem Arduino) zum Arduino geführt werden - jegliche Isolierungen etc. inklusive.


Funktionsweise des Systems[Bearbeiten]

An einen Arduino UNO werden Wiegezellen und LED-Lampen angeschlossen, welche in mehreren Waageplatten verteilt (hier drei) untereinander vernetzt werden. Die Waagen werden einer bestimmten 'Reihenfolge' nach geschaltet, sodass die dieser Reihenfolge nach erste der Waage zugehörigen LED zum Start des Systems anfängt zu leuchten. Somit wird dem Nutzer direkt die vorgegebene erste Materialkiste angezeigt aus der ein Bauteil herausgenommen werden muss. Registriert nun die vorgesehene Waage eine Gewichtsveränderung, dessen Faktor gemessen des Gewichts des Bauteils eingestellt werden kann, erlöscht die zugehörige LED und das System wiederholt diesen Schritt für jede folgende Kiste und LED. Über den Code (für Details siehe unten) können Reihenfolge der Waagen und 'Herausnahmefaktor' (Gewicht) konfiguriert werden. Grundsätzlich ist das System beliebig skalierbar, allerdings wäre eine Anpassung der Elektronik, in Form von Integrierung eines Steckbretts erforderlich, um LEDs und Waagen mit dem Arduino, welcher eine limitierte Anzahl von Steckplätzen (Pins) mitbringt, zu verbinden. Um das Prinzip des Systems darzustellen, wurde ein aus insgesamt drei Waagen bestehendes System als ausreichend befunden.

Vernetzte Waagen
Darstellung der Verkabelung: Wägezelle-HX711-Arduino (Quelle)


Programmierung[Bearbeiten]

Die zu inkludierende Bibliothek des HX711 Sensors finden Sie hier: HX711.


Initialisieren der Variablen
  • Im ersten Teil des Programmcodes werden die Variablen angelegt und initialisiert. Der zugewiesene Wert entspricht der Pinbelegung am Arduino. So ist beispielsweise der DOUT Anschluss des ersten HX711 Sensors mit Pinsteckplatz 5 am Arduino verbunden, der SCK Anschluss mit Pinsteckplatz 4 usw. - Die Variablen der LEDs folgen dem selben Schema.
  • Das Makro HERAUSNAHME_FAKTOR definiert einen festgelegten Wert (hier 10) , welcher dem Programm sagt, ab wie viel Gramm Veränderung reagiert werden soll. Die LED springt also um, sobald 10g Gewicht von der aktiven Waage genommen wurden. Der Wert kann natürlich verändert werden - es wäre auch möglich jeder Waage einen eigenen Faktor zu geben, dies erfordert dann mehrere Makros (oder Variablen).

#include "HX711.h"
#define HERAUSNAHME_FAKTOR 10 //Ab wie viel Gramm soll es als herausgenommen erkannt werden?

//*************** Variablen für die Waage ************************************************
const int LOADCELL_DOUT_PIN_WAAGE1 = 5;
const int LOADCELL_SCK_PIN_WAAGE1 = 4;

const int LOADCELL_DOUT_PIN_WAAGE2 = 3;
const int LOADCELL_SCK_PIN_WAAGE2 = 2;

const int LOADCELL_DOUT_PIN_WAAGE3 = 7;
const int LOADCELL_SCK_PIN_WAAGE3 = 6;
//*****************************************************************************************

//*************** Initialisierung der LEDs ************************************************
const int LED1 = 9;
const int LED2 = 8;
const int LED3 = 10;
//****************************************************************************************

HX711 scale1 , scale2 , scale3;
float currWeight = 0; // Aktuell gemessenes Gewicht
int anzahltGebauteTeile = 0; // Zählt wie viele Bauteile der Nutzer gebaut hat
int count = 1; //Variable um die aktive Waage zu bestimmen

Setup
  • Zu erst wird der Serielle Port für die Konsolenausgabe geöffnet und mit einer Baud Rate von 9600 eingestellt. Dies ist für Debug Ausgaben hilfreich und sinvoll. Die Methode initialize_Scale() wird in den kommenden Abschnitten näher erklärt, hier werden die Waagen tariert und für die Messung in Gramm eingestellt.
  • Der Pin Mode für die LEDs wird festgelegt, sodass der Arduino sie ansteuern kann. Die erste LED soll von Beginn an leuchten und wird auf HIGH gestellt.


Loop
  • Hier wird mit einer counter Variable und einem Switch-Case Statement gearbeitet, um die jeweils aktive Waage zu bedienen. Das aktuelle Gewicht der aktiven Waage wird ausgelesen und sollte durch die Tarierung nahe 0 sein. Nun wird das gemessene Gewicht zusammen mit der Waage an die Methode check_weightChange(float, * HX711) übergeben und auf Veränderungen geprüft. Besteht eine Differenz von -10g (HERAUSNAHME_FAKTOR) wird der Counter hochgezählt und die LED springt um. Die danach folgenden Serial Ausgaben dienen dem Debugging und können auch weggelassen werden. Das delay von 100ms verlangsamt zwar etwas die Performance, beugt aber Messfehlern vor.
void setup() {

  Serial.begin(9600);
  initialize_Scale(); // Waagen kalibrieren

  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);

  digitalWrite(LED1, HIGH); //LED der ersten Box leuchtet von Beginn an
  digitalWrite(LED2, LOW);
  digitalWrite(LED3, LOW);

}

void loop() {

  switch (count) {
    case 1:
      currWeight = scale1.get_units(10);
      check_weightChange(currWeight, &scale1); //Wenn sich das Gewicht ändert leuchtet die nächste LED
      Serial.println("Gewicht Waage 1: ");
      Serial.println(currWeight);
      scale1.power_down();
      delay(100);
      scale1.power_up();
      break;
      
    case 2:
      currWeight = scale2.get_units(10);
      check_weightChange(currWeight, &scale2); //Wenn sich das Gewicht ändert leuchtet die nächste LED
      Serial.println("Gewicht Waage 2: ");
      Serial.println(currWeight);
      scale2.power_down();
      delay(100);
      scale2.power_up();
      break;

    case 3:
      currWeight = scale3.get_units(10);
      check_weightChange(currWeight, &scale3); //Wenn sich das Gewicht ändert leuchtet die nächste LED
      Serial.println("Gewicht Waage 3: ");
      Serial.println(currWeight);
      scale3.power_down();
      delay(100);
      scale3.power_up();
      break;
  }

}


initialize_Scale()
  • Diese Methode Kalibriert nacheinander die Waagen.
  1. Es wird ein Grundwert bestimmt und durch read_average(10) ein Durchschnitt aus 10 Werten gebildet.
  2. get_value(5) bestimmt 5 Durchschnittswerte minus dem Tare Wert (noch nicht gesetzt).
  3. get_units(5) bestimmt 5 Durchschnittswerte minus dem Tare Gewicht geteilt durch den setScale Wert (auch noch nicht gesetzt).
  4. set_scale(437.f) setzt einen sogenannten Skalierungsfaktor , welcher entscheidet , ob die Waage in Gramm, Kilogramm , Tonnen usw. messen soll. Der Faktor ist für Gramm Messungen, speziell für diese Vorrichtung bestimmt worden und deswegen (eventuell) nicht einfach so übertragbar.
  5. Nun wird Tariert und die Schritte 1-3 wiederholt, diesmal mit den gesetzten Werten - Die Waage ist nun bereit für Messungen.


void initialize_Scale() {
  Serial.println("Starte Kalibrierung...");

  //*********************** Kalibrierungsdaten erfassen **********************************************************************

  scale1.begin(LOADCELL_DOUT_PIN_WAAGE1, LOADCELL_SCK_PIN_WAAGE1);
  scale1.read();
  scale1.read_average(10);
  scale1.get_value(5);
  scale1.get_units(5);

  scale1.set_scale(437.f); // Skalierungsfaktor für Gramm muss evtl für andere Waagen neu eingestellt werden sonst Messfehler. 
  scale1.tare();

  scale1.read();
  scale1.read_average(10);
  scale1.get_value(5);
  scale1.get_units(5);

  Serial.println("Kalibrierung für Waage 1 abgeschlossen!");


  scale2.begin(LOADCELL_DOUT_PIN_WAAGE2, LOADCELL_SCK_PIN_WAAGE2);
  scale2.read();
  scale2.read_average(10);
  scale2.get_value(5);
  scale2.get_units(5);

  scale2.set_scale(437.f); // Skalierungsfaktor für Gramm muss evtl für andere Waagen neu eingestellt werden sonst Messfehler. 
  scale2.tare();

  scale2.read();
  scale2.read_average(10);
  scale2.get_value(5);
  scale2.get_units(5);

  Serial.println("Kalibrierung für Waage 2 abgeschlossen!");

  scale3.begin(LOADCELL_DOUT_PIN_WAAGE3, LOADCELL_SCK_PIN_WAAGE3);
  scale3.read();
  scale3.read_average(10);
  scale3.get_value(5);
  scale3.get_units(5);

  scale3.set_scale(437.f); // Skalierungsfaktor für Gramm muss evtl für andere Waagen neu eingestellt werden sonst Messfehler. 
  scale3.tare();

  scale3.read();
  scale3.read_average(10);
  scale3.get_value(5);
  scale3.get_units(5);

  Serial.println("Kalibrierung für Waage 3 abgeschlossen!");

   //***************************************************************************************************************************
}
check_weightChange(float , *HX711)
  • Diese Methode überprüft, ob sich das gemessene Gewicht der aktiven Waage verändert. Programmiertechnisch werden die Sensordaten über eine Instanz vom Typ HX711 verarbeitet, welche hier als Zeiger übergeben wird (Call by Reference).
  • Durch die Tarierung ist der Ausgangswert Null. Sobald eine Differenz von +10g (HERAUSNAHME_FAKTOR) zum aktuellen Gewicht verzeichnet wird , wird die Waage neu Tariert. Die LED springt nicht um, denn die Kiste wurde aufgefüllt. Ist jedoch eine Gewichtsabnahme zu verzeichnen, wird der counter hochgezählt und die LED springt um. Zudem wird die Variable anzahltGebauteTeile hochgezählt, wenn der Counter bei 3 ist - ein Bauzyklus ist nun abgeschlossen.
void check_weightChange(float curr_weight, HX711 *scale) {

  if ((0 + HERAUSNAHME_FAKTOR) <= curr_weight) {
    Serial.println("Kiste wurde aufgefüllt!");
    scale->tare();

  } else if ((0 - HERAUSNAHME_FAKTOR) >= curr_weight) {

    Serial.println("Bauteil wurde aus der Box genommen");

    if (count == 3) {
      count = 1;
      activate_NextLED(count); //Erste LED wird aktiviert
      anzahltGebauteTeile += 1;

    } else {
      count += 1;
      activate_NextLED(count); //Zweite oder dritte LED wird aktiviert
    }

    scale->tare();
  }
}
activate_NextLED(int)
  • Dieser Methode wird eine int Variable LED_Number übergeben. In der check_weightChange Methode nutzt man direkt die vorhandene counter Variable, welche ja bereits die aktive Waage kennzeichnet und damit auch die aktive LED. So lässt sich leicht bestimmen , welche LED aktuell leuchten muss. Die digitalWrite() Funktion setzt entsprechend den Aktivierungszustand der LED Lampen auf an oder aus.
void activate_NextLED(int LED_Number) {
  switch (LED_Number) {
    case 1:
      Serial.println("LED1 wird aktiviert");
      digitalWrite(LED1, HIGH);
      digitalWrite(LED2, LOW);
      digitalWrite(LED3, LOW);
      break;
    case 2:
      Serial.println("LED2 wird aktiviert");
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, HIGH);
      digitalWrite(LED3, LOW);
      break;
    case 3:
      Serial.println("LED3 wird aktiviert");
      digitalWrite(LED1, LOW);
      digitalWrite(LED2, LOW);
      digitalWrite(LED3, HIGH);
      break;
  }
}


Zukunftsaussichten[Bearbeiten]

Während, sowie nach Fertigung des Prototypen, sind zusätzliche mögliche Weiterentwicklungen des Systems erarbeitet worden. So ließe sich durch ein Zusammenfassen der gesamten gefertigten Teile eine Art 'Gamification' für den/die Nutzer des Diakonischen Werks ermöglichen. Beispielsweise, wer die meisten Teile für den Tag gebaut hat oder wie sich die Leistung im Vergleich zu anderen Tagen bei Nutzern ändert. Weiterhin ist eine Umkehr des Systems, hinsichtlich Teile in sich auf den Auflageplatten befindliche Kisten zu sammeln anstelle herauszunehmen und durch einen festlegbaren Schwellwert genaue Mengen von Teilen gesammelt werden können. Dieser Ansatz ist besonders für die Logistikindustrie interessant nicht zuletzt aufgrund der Robustheit der Waagen und Skalierbarkeit des Systems. So sind Montageprozesse mit zahlreichen Zwischenschritten, ausgestattet mit einem Assistenzsystem wie diesem, zugänglicher und weniger Fehleranfällig zu machen, wie uns während der Präsentation durch Anwendungsbeispiele eines Interessenten klar wurde. Zusätzlich ist das Gesamtsystem mit den dazugehörigen Komponenten kostengünstig (siehe 'Komponenten'), was einen weitreichenden Ausbau für industrielle Partner und Interessenten attraktiv macht.