Geschwindigkeitsmessung mit Messrad


Google-Suche auf MEINE-SCHALTUNG.de :





Online Rechner

Chronik

Dauerkalender


Positionierung

mit Baumer-Inkrementalgeber und Arduino

Mit der folgenden Schaltung werden wir mithilfe eines Inkrementalgebers eine Achse absolut positionieren. Für eine solche Aufgabe wäre ein Absolut-Inkrementalgeber eine bessere Wahl. Bei diesen Gebern kann man die aktuelle Position direkt nach dem Einschalten ermitteln. Beim Positionieren mit einem Inkrementalgeber muss, bevor man automatische Abläufe einleitet, zunächst referenziert werden. Man fährt eine feste und bekannte Position an und nullt den Zähler.

Die Aufgabe ist sehr einfach. Ein Inkrementalgeber soll, abwechselnd im Uhrzeigersinn und gegen den Uhrzeigersinn fahrend, jeweils eine feste Zielposition erreichen. Er ist mithilfe eines Zahnriemens und zwei Umlenkrollen mit einem Motor verbunden. Die Bewegung des Motors soll auf der Basis der gezählten Inkremente des Gebers erfolgen.

motor_mit_baumer_geber

Motor und Geber startbereit.

Die Schaltung arbeitet mit zwei Geschwindigkeiten. Die Hauptbewegung des Motors erfolgt mit einer höheren Geschwindigkeit. Erst kurz vor dem Ziel wird auf eine niedrigere Positionierungsgeschwindigkeit umgeschaltet. So kann man „genauer“ das Ziel erreichen. Ist die Geschwindigkeit zu hoch, schießt man übers Ziel hinaus. Eine dann erforderliche Rückwärtsbewegung ist meistens unerwünscht und kostet Zeit. In den industriellen Anlagen wird die Geschwindigkeit des Motors kurz vor dem Ziel, entsprechend der eingestellten Rampe, sukzessiv heruntergefahren, bis der Antrieb im Ziel zum Stillstand kommt (Servoantriebe).
Bei dem Motor, der den Geber bewegen soll, handelt es sich um einen Gleichstrommotor mit eingebauten Getrieben. Seine Steuerung übernehmen insgesamt drei Relais. Mit K1 wird die Drehrichtung des Motors geändert, mit K2 wird der Motor mit etwas höherer (schnell fahren), mit K3 mit etwas niedrigerer Spannung versorgt (Langsam fahren). Der Stromkreis der Steuerrelais und des Motors ist mit einem Optokoppler von der restlichen Steuerung getrennt. Die Spannungen für den Motor können frei gewählt werden (hier ca. 5V und 10V).

Steuerrelais

Motor - Steuerrelais

In der Schaltung werden drei Taster verwendet. Mit S1 kann die Achse auf die gewünschte Position, die anschließend als Ziel definiert werden kann, gebracht werden. Dies geschieht mit dem Taster S3 (Reset). Mit dem Taster S2 (Automatik Ein / Aus) wird der automatische Ablauf gestartet.

taster_der_schaltung.jpg

Taster Tippen, Auto und Reset

Bei dem Geber handelt es sich um einen Inkrementalgeber von Baumer mit der Bezeichnung BDK 16.24.K500. Er wird mit 24VDC betrieben. Da die Spannung für Arduino zu hoch ist, werden die 24V – Signale mit einfachen Spannungsteilern auf ca. 5V runtergesetzt. Der Geber liefert 500 Inkremente pro Umdrehung. Es stehen drei Spuren zur Verfügung: A,B und N. Das Referenzsignal N wird in diesem Versuch nicht ausgewertet.

Geber Baumer BDK

Baumer-Geber

Die Koordination aller Elemente übernimmt Arduino Mega 2560.

Arduino

Arduino

Der Schaltplan

Schaltplan: Positionierung mit Baumer

Schaltplan: Positionierung mit Baumer Inkrementalgeber. (Arduino ohne USB-Anschluss oder Netzteil: Vin > 6 V)

Aufgebaute Testschaltung

Testschaltung

Aufgebaute Testschaltung

Das Programm

In dem Programm dreht sich alles um Inkremente. Um die Inkremente zählen zu können, wird mit dem Aufruf:

attachInterrupt(digitalPinToInterrupt(PinA), Inkremente, CHANGE);

ein Interrupt definiert. Die Aktivierung des Interrupts erfolgt sobald ein Flankenwechsel am Eingang 2 (PinA) erkannt wird. Sobald dies geschieht, wird das Unterprogramm "Inkremente ()" aufgerufen und ausgeführt. Für diesen kurzen Moment wird das Hauptprogramm unterbrochen und erst nachdem Interrupt mit seinen Aufgaben fertig ist, fortgesetzt. In dem Unterprogramm wird der Wert der Variable „Zähler“ aktualisiert. Da wir einen Geber mit 500 Inkrementen pro Umdrehung haben, erreicht der Zähler nach einer vollen Umdrehung den Wert 1000. Nach dem Start wird der Motor zunächst in eine Richtung bewegt. Sobald der Zählerwert den Wert 1000 erreicht, wird der Motor gestoppt. Anschließend erfolgt die Bewegung in die entgegengesetzte Richtung. Der Zähler wird hier dekrementiert und bei dem Wert 0 wird der Motor wieder gestoppt. Danach wiederholt sich der Vorgang.

Man kann die Aufgabe der Zählung der Inkremente auch ohne Interrupt erledigen. Doch in diesem Fall besteht die Gefahr, dass manche Signale nicht erkannt werden. Mit dem Interrupt erfolgt die Zählung in Echtzeit.

Vor dem Start wird die Zielposition per Hand angefahren und der Zähler mit der Reset-Taste auf den Wert 0 gesetzt.

// *******************************************************************
// Inkrementalgeber
// Arduino Mega 2560 R3
// Inkrementalgeber Baumer (500 Inkremente / U)
// *******************************************************************
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 9, 10, 11, 12, 13);

int PinA = 2;                                          // Inerrupt-Pin
int PinB = 3;

int TA_Tipp = 49;                                     // Taster Tippen
int TA_Auto = 51;                        // Taster Automatik Ein / Aus
int TA_Reset = 53;                             // Taster Zähler nullen
int K1_Richtung_Um = 48;                  // Relais K1 Richtung ändern
int K2_Schnell = 50;                       // Relais K2 schnell drehen
int K3_Langsam = 52;                       // Relais K3 langsam drehen
int Zaehler = 0;                                // Inkremente Ist-Zahl
bool Auto = false;
bool AutoM = false;
int Schritt;

unsigned long MillisAktuell = 0;                 // Verzögerungszeiten
unsigned long Wartezeit = 1000;
unsigned long ZeitStart = 0;
unsigned long DisplayZeit = 0;

// SetUp -------------------------------------------------------------
void setup() {
  pinMode (PinA, INPUT);
  pinMode (PinB, INPUT);
  attachInterrupt(digitalPinToInterrupt(PinA), Inkremente, CHANGE);

  pinMode (TA_Tipp, INPUT_PULLUP);
  pinMode (TA_Auto, INPUT_PULLUP);
  pinMode (TA_Reset, INPUT_PULLUP);
  pinMode (K1_Richtung_Um, OUTPUT);
  pinMode (K2_Schnell, OUTPUT);
  pinMode (K3_Langsam, OUTPUT);
}

// Interrupt - Programm (Inkremente erfassen und zählen) -------------
void Inkremente () {
  bool WertA = digitalRead(PinA);
  bool WertB = digitalRead(PinB);
 if (WertA==true && WertB==false || WertA==false && WertB==true){
    Zaehler++; }
 if (WertA==false && WertB==false || WertA==true&& WertB==true){
   Zaehler--; }
}

// Anzeige aktualisieren ---------------------------------------------
void LCD_Display () {
  DisplayZeit = MillisAktuell;
  lcd.begin(20,4);
  lcd.setCursor(2, 0);
  lcd.print ("Inkrementalgeber"); 
  lcd.setCursor(3, 2);
  lcd.print ("Zaehler: ");
  char buffer[5];
  sprintf(buffer,"%5i",Zaehler);
  lcd.print (buffer);
}

// Hauptprogramm -----------------------------------------------------
void loop() {
  MillisAktuell = millis();
  if (MillisAktuell > DisplayZeit + 300) {
    LCD_Display (); }

  // Tippen ----------------------------------------------------------
  if (not Auto) {
    if (digitalRead(TA_Tipp) == LOW) {
      digitalWrite(K3_Langsam,HIGH); } 
    else { digitalWrite(K3_Langsam,LOW); } }
      
  // Zähler nullen ---------------------------------------------------
  if (digitalRead(TA_Reset) == LOW) {
    Zaehler = 0; }
    
  // Auto Ein / Aus --------------------------------------------------
  if (digitalRead(TA_Auto) == HIGH) { AutoM = true; }  
  if (digitalRead(TA_Auto) == LOW && AutoM == true ) {
    Auto = not Auto;
    AutoM = false; 
    if (Auto) { Schritt = 1; }
    if (not Auto) {
      digitalWrite(K1_Richtung_Um,LOW);
      digitalWrite(K2_Schnell,LOW);
      digitalWrite(K3_Langsam,LOW);} }

  // Automatischer Ablauf --------------------------------------------
  if (Auto) {
    switch (Schritt) {
      case 1:  
        digitalWrite(K2_Schnell,HIGH);
        if (Zaehler >= 900) { Schritt = 2; }
        break;
      case 2: 
        digitalWrite(K2_Schnell,LOW);
        digitalWrite(K3_Langsam,HIGH);
        if (Zaehler >= 1000) { Schritt = 3; } 
        break; 
      case 3: 
        digitalWrite(K3_Langsam,LOW);
        ZeitStart = MillisAktuell;
        Schritt = 4; 
        break; 
      case 4:  
        if (MillisAktuell > ZeitStart + Wartezeit) { Schritt = 5; } 
        break;
      case 5:  
        digitalWrite(K2_Schnell,HIGH);
        digitalWrite(K1_Richtung_Um,HIGH);
        if (Zaehler <= 100) { Schritt = 6; } 
        break;
      case 6: 
        digitalWrite(K2_Schnell,LOW);
        digitalWrite(K3_Langsam,HIGH);
        if (Zaehler <= 0) { Schritt = 7; } 
        break;
      case 7: 
        digitalWrite(K3_Langsam,LOW);
        digitalWrite(K1_Richtung_Um,LOW);
        ZeitStart = MillisAktuell;
        Schritt = 8; 
        break; 
      case 8: 
        if (MillisAktuell > ZeitStart + Wartezeit) { Schritt = 1; } 
        break; 
      }   
   }
}       
// *************************************************************        


Kurzvideo

Kurzvideo


Weitere Themen:


Google-Suche auf MEINE-SCHALTUNG.de :


Home Impressum Datenschutz