Dauerkalender

Längenmessung mit Messrad

(Inkrementalgeber, Arduino Uno, LCD 20x4)

Unter vielen Techniken, die eine Längenmessung ermöglichen, gehört die Messung mit einem Messrad und Inkrementalgeber zu den sehr verbreiteten Methoden. Ein großer Vorteil der Lösung ist, dass neben der Längenmessung z.B. auch Geschwindigkeit des Materials gemessen werden kann. Die Methode eignet sich vor allem dort, wo mit „endlos“ langen Materialien gearbeitet wird.
Das Messprinzip ist dabei äußerst simpel. Eine Messradeinrichtung besteht aus einem Messrad, das auf dem Material aufliegt und dessen Umfang bekannt ist, sowie einem Drehimpulsgeber, der pro volle Umdrehung eine bekannte Anzahl an elektrischen Impulsen generiert.
Während der Messung werden die elektrischen Impulse des Drehgebers erfasst und mit der Länge, die pro einen Impuls abgefahren wird, multipliziert.
In unserem Beispiel kommt ein Impulsgeber mit 500 Impulsen pro Umdrehung zum Einsatz. Das Messrad, das spielfrei mit dem Impulsgeber verbunden ist, hat einen Durchmesser von D = 29,2 mm. Daraus folgt, dass der Umfang des Messrades (U = π * D) U = 91,73 mm beträgt.
Indem wir jetzt den Umfang durch Anzahl der Impulse pro eine volle Umdrehung dividieren, erhalten wir den Weg, der vom Material pro Impuls zurückgelegt wird. In diesem Fall beträgt er 0,183455 mm.
Die Aufgabe der Schaltung beschränkt sich jetzt lediglich auf korrekte Zählung der Impulse. Der Mikrocontroller kann dann anschließend mit der Formel
Länge = Anzahl der gezählten Impulse * Weg pro Impuls
den gesamten abgefahrenen Weg errechnen.

Messrad

Als Messrad fungiert in unserer Schaltung ein kleines Rad aus der Welt der Legobausteine. Normalerweise wird das Rad für Lego-Fahrzeugbau verwendet. Damit das Rad nicht auf dem Material rutscht, bekam es zusätzlich eine Außengummierung. Der Gummiring ist nichts anderes als eine Gummidichtung für Wasserventile. Für professionelle Anwendungen ist diese Komposition eher ungeeignet, für unsere Zwecke wohl völlig ausreichend. Das Rad ist auf einer Lego-Achse montiert, die wiederum über eine kleine Kupplung mit dem Drehimpulsgeber spielfrei verbunden ist.

Impulsgeber

Die zu zählenden Impulse stammen in unserer Schaltung von dem Drehimpulsgeber Kübler 05.2400.1222.0500. Der Geber arbeitet mit Spannungen 5 VDC bis 24 VDC. Es werden 500 Impulse pro Umdrehung geliefert. Da der Geber mit zwei Spuren (A und B) arbeitet, ist es möglich, die aktuelle Drehrichtung des Gebers zu erkennen. Mit Abmessungen von ca. 25x25 mm kann der Geber durchaus als Miniaturdrehgeber bezeichnet werden.

Arduino UNO

Die Zählung der Impulse, die der Drehgeber liefert, und anschließende Umrechnung auf Länge übernimmt der Mikrocontroller Arduino Uno. Die Aufgabe ist nicht besonders kompliziert, es werden auch keine großen Speicherkapazitäten benötigt, so, dass auch andere weniger leistungsfähigere Mikrocontroller der Aufgabe durchaus gewachsen wären. Die Aufgabe in unserer Testschaltung besteht aus Zählung der Impulse, schneller Umrechnung auf Länge und Anzeige des Ergebnisses auf einem Display.

Anzeige

Die Ergebnisse werden auf dem LCD Display 20 Zeichen x 4 Zeilen angezeigt. Auf der Rückseite des Displays ist der I2C-Treiber FC-113 angelötet. Dank der Maßnahme werden Steuerleitungen gespart. Ohne den Treiber benötigt das Display bedeutend mehr Steuerleitungen.

Motor

Als Zugmaschine, die das zu messende Endlosmaterial bewegt, tritt in unserer Schaltung ein 12-V-Gleichstrommotor auf. Er wird während des Tests manuell bei Bedarf ein- und ausgeschaltet. Die nominale Spannung des Motors beträgt 12 VDC. Durch Verringerung der Spannung kann man die Drehzahl des Motors reduzieren. Während des Tests betreiben wir den Motor mit ca. 9VDC.

Spannungsregler LM2596

Immer wenn unterschiedliche Spannungen ins Spiel kommen, haben Spannungsregler ihren Auftritt. In diesem Fall arbeiten wir mit zwei Spannungen. Die Versorgungsspannung von ca. 9 VDC, die für den Motor und Inkrementalgeber gebraucht wird, muss für die restlichen Geräte auf 5 VDC runtergeregelt werden. Bei der Wahl des Spannungsreglers muss neben Spannung auch die Stromaufnahme einzelnen Komponenten berücksichtigt werden. In diesem Fall, da wir hier mit Arduino, einem Display, Signalgeber und einem Relais zu tun haben, liegt der Strombedarf weit über 100 mA. Das Spannungsregler-Modul mit dem Regler LM2596,, das hier zum Einsatz kommt, kann bei Bedarf einen Strom bis zu 3 A liefern.

Relais

Bei dem hier eingesetzten Relaismodul handelt es sich um ein Modul mit dem Relais SRD-05VDC-SL-C. Das Relais wird mit dem Schalter S1 (Schaltplan) aktiviert. Mit ihm wird der Motor ein- bzw. ausgeschaltet.

Spannungsregler 78L

In der Schaltung werden zwei Spannungsregler aus der Reihe 78L05 verwendet. Ihre Aufgabe ist lediglich, die Signale des Inkrementalgebers an die Eingänge des Arduino Uno anzupassen. Arduino arbeitet mit 5VDC, die Signale des Gebers, da er an die Hauptspannungsversorgung von 9VDC angeschlossen ist, können deutlich höher liegen.

Schaltplan

Testschaltung

Das Programm

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 20, 4);           // Adresse, Zeichen, Zeilen

int Spur_A = 2;                               // Digital Eingang D2 für Spur A
int Spur_B = 3;                               // Digital Eingang D3 für Spur B

int Zaehler = 0;

void setup() {
    lcd.init();                               // Display initialisieren 
    lcd.clear();
    lcd.backlight();                          // Hintergrundbeleuchtung
    lcd.setCursor(3,0);                       // Cursor Position
    lcd.print("Laengenmessung");              // Displayausgabe
    lcd.setCursor(4,1);
    lcd.print("mit MESSRAD");
    lcd.setCursor(1,2);              
    lcd.print("PULSE  = ");
    lcd.setCursor(1,3);              
    lcd.print("LAENGE = ");    
    lcd.setCursor(15,3);              
    lcd.print("mm");        
    pinMode(Spur_A, INPUT);
    pinMode(Spur_B, INPUT);
                                              // Interrupt wird ausgelöst, wenn
                                              // Änderung am Eingang D2 eintritt
    attachInterrupt(digitalPinToInterrupt(Spur_A), Inkremente, CHANGE);
}

void Inkremente () {                          // Interrupt - Unterprogramm
    bool Wert_A = digitalRead(Spur_A);        // D2 abfragen
    bool Wert_B = digitalRead(Spur_B);        // D3 abfragen
    if (Wert_A == true && Wert_B == false) {  // Zählung bei Techtsdrehung
        Zaehler++;
    }
    if (Wert_A == false && Wert_B == false ){ // Zählung bei Linksdrehung
        Zaehler--;
    }
}

void loop() {
    String Ausgabe = String(Zaehler);         // Vorbereitung zur Ausgabe auf LCD
    lcd.setCursor(10,2);                      // Cursor Position
    lcd.print(Ausgabe);                       // LCD Ausgabe

    int Laenge = Zaehler * 0.183455;          // Länge in mm
    Ausgabe = String(Laenge);
    lcd.setCursor(10,3);
    lcd.print(Ausgabe);    
}       
// ***************************************************************************        
        

Kurzvideo

Kurzvideo

Weitere Themen: