Drehwinkel erfassen und ausgeben (Drehencoder)

Hallo zusammen,

ich schreibe gerade meine Bachelorarbeit und benötige eure Hilfe. Ich baue einen Prüfstand für Zahnräder bei dem das “Verdrehflankenspiel” gemessen werden soll. Dazu wird die Welle um ungefähr max. 1-5° gedreht. Meine Messung sollte aber auch im Minutenbereich liegen.

Da ich eine komplette Null auf dem Gebiet der Sensortechnik bin, bräuchte ich hier Hilfe wie und ob diese Messung überhaupt vollzogen werden kann.

Ich möchte mit einem Arduino und einem Drehencoder mein Flankenspiel messen, wie muss ich denn dann das Arduino programmieren das er mir einen Winkel ausgibt??? Toll wäre es auch wenn der Arduino noch mit einem Display verknüpft werden könnte, auf dem der Winkel abgelesen werden kann.

Über Antworten würde ich mich sehr freuen, da ich momentan echt am verzweifeln bin.
Evtl. wäre auch noch eine Liste mit den Teilen die ich benötige von Vorteil da ich wie oben erwähnt ein Laie und eine totale Null bin.

Grüße

CptSlow

Hallo und Guten Tag CptSlow,

schau mal hier http://playground.arduino.cc/Main/RotaryEncoders

und hier .. Nr.14 LCD Display | Funduino - Kits und Anleitungen für Arduino

dort stehen auch Beispiele.

Grüße, Stefan

Hallo,

Displayausgabe ist eine Sache, die kann man separat programmieren, testen und dann einbauen.

Winkelausgabe?
Du kennst die Auflösung deines Encoders für volle 360°. Also wieviel Impulse pro volle Umdrehung.
Damit kennst du die Auflösung > Impulse/Grad oder Grad/Impuls, wie auch immer.
Musste eigentlich nur umrechnen und dann statt serial.print dann lcd.print verwenden.

Dankeschön für Eure Antworoten, wie ist das wenn ich eine Übersetzung einbauen würde, ich kann den Sensor nicht direkt an die Welle schrauben sondern muss ihn quasi über ein "Reibrad" mit der Welle verbinden. Sieht dann quasi so aus oO. Dazu müsste ich dann noch das übersetzungsverhältnis mit einprogrammieren, reicht das wenn ich dann den Wert einfach nur durch das Übersetzungsverhältnis teile oder muss das anderweitig programmiert werden?

Reibrad und Genauigkeit im Minutenbereich ..... uhhhh .... :o

Letztlich ist der mechanische Aufbau und die Auflösung entscheidend. Der Rest ist Software bzw. einfache Rechnerei.

Hallo,

wenn man den Reibungsverlust vernachlässigt, muss man hier scheinbar, musst auf satten mechanischen Kontakt der Räder achten, dann musste wirklich nur das Übersetzungsverhältnis mit in die Umrechnung einbeziehen.

Oder nimmst wenigstens einen Zahnriemen mit entsprechenden Rädern dazu an beide Wellen.
Dann würde ich behaupten wollen das damit der Reibverlust gegen Null geht.
Nur ein Restspiel bliebe erhalten wenn man ständig kurz hin und her drehen würde.

Nur jetzt muss ich mal fragen. Was studierst du eigentlich? Weil die Fragen eigentlich nichts mit programmieren zu tun haben.

Ich studiere Maschinenbau Fachrichtung Fahrzeugtechnik und hatte aus diesem Grund keine Sensortechnik wie sie bei den Leuten mit Konstruktion und Entwicklung zu tun haben. Wie gesagt die Idee befindet sich in meinem Kopf und auch schon zeichnerisch im CAD. Nur eben mit der Umsetzung mit der Programmierung und das Anschließen des Potentiometers das sind für mich eben andere Welten. Klingt blöd aber wenn ich mir solche Datenblätter anschaue dann verstehe ich zwar was ich damit machen kann nur eben weiß ich nicht wie ich es eben dann “Programmiertechnisch” umsetzen kann. Ich bin da eher der wo alles schon fertig haben will. Quasi nur noch hin montieren und das Teil muss laufen :).

Hatte Anfangs eine mechanische Lösung was aber für meine nachfolgenden Benutzer zu umständlich wäre, daher möchte ich eben auf eine “Digitale Ausgabe” zurückgreifen in der man nur noch den Wert ablesen muss.

Grüße

CptSlow

Hallo,

wenn du Maschinenbau studierst, musst du dich ja mit dem Thema Getriebe usw. bestens auskennen. Dann habe ich deine Frage vielleicht auch falsch herum verstanden. Weil das müsstest du mir ja eher erklären wie ich dir. :slight_smile:
Im Grunde musst du nichts weiter tun, wie deine Formeln vom Papier in die IDE übertragen.
Wenn es noch hängen sollte, zeige uns deine Formeln, für nicht studierte, ich/wir können das bestimmt in Form gießen.

Bsp. dein Encoder hat 100 Pulse pro Umdrehung, dann hat er eine Auflösung von 3,6° pro Puls. 360/100=3,6
Wenn du das noch untersetzt im Verhältnis 1:2, dann haste 1,8° pro Puls.
x = 360 / 100 / 2

genauso schreibste die Formel in die IDE.

definierste eine Ergebnisvariable x als float und musst möglichst bei einer Konstanten noch ein ".0" ranhängen, damit auch float gerechnet wird. Bsp.weise so oder ähnlich

x = 360.0 / 100 / 2;

Etwas fertiges gibts von mir nur noch in Ausnahmefällen, falls es zufällig mein Lieblingsthema trifft. Für einen Studenten ist Hilfe zur Selbsthilfe eh am Besten. Er möchte es ja studieren und nicht kopieren. Das am Rande. Nicht falsch verstehen und nicht persönlich nehmen.

Hallo!

Hast du schon einen bestimmten Encoder im Auge dafür?

Die meisten preiswerten Encoder ( so im Preisbereich von einigen wenigen Euro), die man überall
im Netz findet, eignen sich dafür wohl eher nicht, da sie meist so eine Drehauflösung zwischen
12 - 20 Werten pro Umdrehung haben,
die preiswertesten mit 100er Auflösung sind dagegen richtig "fette Trümmer" mit sehr guter
Griffigkeit, werden für Drehbank-Einstellungen etc genutzt.
Da ist dann auch der schwere solide Alu-Drehkopf auch fest eingebaut, eine Rastfunktion,
die eingebaut ist, kann man mit etwas Tüfteln "rausoperieren", dann laufen die sehr
feinfühlig und phantastisch.

Davon habe ich einige eingebaut in einen Controller für Final Cut Pro X, um die Bildmanipulation
sehr feinschrittig zu kontrollieren (mittels selbstentworfenem Midi-Controller)

Wenn Interesse besteht, kann ich mal raussuchen, wie das Teil heißt und wer das liefert.

Viel Spaß beim Basteln!

HG

Jo, das interessiert mich auch. Such doch mal bitte raus.

http://de.rs-online.com/web/p/optische-drehgeber/2632889/

habe allerdings auch schon noch fettere Bauformen gesehen.

Nicht schlecht - ich glaub, ich bleib bei meinen Bastelencodern :grin:

Hallo,

für uns zu Eingabezwecken sind die billigen ausreichend. Die fetteren die direkt an Motoren hängen müssen auch die Drehzahlen mitmachen und kosten dann 3 stellig aufwärts, sind eben Industrieprodukte.

So, ich habe mal einen Link hier eingehängt:

Wenn man nach "CNC Hand Wheel" sucht, kommen die richtigen Apparate
in den Blickwinkel, unter Drehencoder findet man die großen Dinger eher nicht.

Der kleine Drehgriff oben drauf kann abgeschraubt werden, und auch die
Rasterung kann ausgebaut werden: Dazu die leicht aufgeklebte Alu-Scheibe
auf dem Kopf des Drehknopfes vorsichtig abhebeln, dann das Innere auseinander
nehmen, die Feder der Rasterung herausziehen und dann wieder zurückbauen,
dauert pro Knopf ein paar Minuten, dann hat man einen extrem feinfühligen
Encoder mit gescheiter 100er Auflösung. Ist allerdings recht groß und schwer,
zu montieren einfach: Auf die Frontplatte draufsetzen, die Schrauben finden
in kleinen Bohrlöchern ihren Platz,
Ansteuerung am Arduino sehr einfach, alle Vorwiderstände sind eingebaut,
wird direkt an 5V und GND angeschlossen, die beiden anderen sind dann die
Signalleitungen (ist auch eindeutig beschriftet).

Wenn gewünscht, kann ich den Sketch zur Ansteuerung noch raussuchen.

Also für Spezialzwecke für genaues Einstellen die ideale Lösung.

Lieferung war bisher bei mir immer innerhalb von ca. 2-3 Wochen.

Und der Preis ist dafür wirklich fair!

HG

Super, gerade einen bestellt :grin:
Wenn Du den Sketch bereitstellst wäre prima - hab gerade meine faule Phase :o

Sowas habe ich auch gesucht und nicht gefunden. Danke für die Info.
Ich habe bestellt.

Gruß Tommy

So, hier habe ich euch mal den Sketch für den Dreh-Encoder eingehängt:

   /* 
   *   Konstruktion eines eigenen Midi-Controllers für Final Cut Pro X
   *   für einen Arduino Mega
   *    
   *   mit 6 großen Dreh-Encodern (keine externen Widerstände nötig, sind im Encoder eingebaut),
   *   (Anschluss an 2-3, 4-5, 6-7, 8-9, 10-11, 12-13)
   *   7 kleinen Dreh-Encodern (externe Pullup-Widerstände 10K nach 5V)
   *   (Anschluss an 14-15, 16-17, 18-19, 20-21, 22-23, 24-25, 26-27)
   *   und 40 Tast-Schaltern (externe Pulldown-Widerstände 10K nach GND)
   *   (Anschluss an 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
   *                 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
   *                 A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)
   *   
   *   Die Eingänge A0 bis A13 werden also gleichfalls als digitale Eingänge genutzt.
   *   Somit sind bis auf A14 und A15 sämtliche I/O-Möglichkeiten des Mega genutzt
   *   
   *   Ausgegeben werden pro Element 3 Bytes an Midi-Werten:  
   *   Als erstes Byte für alle gleich der Wert 176 - Codierung des ControlChange-Befehls für Midi-Kanal 1,
   *   als zweites Byte die Controller-Nummer (hier von 1 - 52),
   *   als drittes Byte entweder 0 oder 127.
   *   Der Sketch liefert die Werte an den Mac - Midi-Treiber "Hairless Midi-Bridge",
   *   der auf dem Mac die Daten dann weiter an das Programm "Midi-Translator" liefert.
   *   Dieses übersetzt die Midi-Informationen in Tastaturbefehle für Final Cut Pro X.
   */

// =============== Initialisierung der Werte ===============================

//  ------ Für Funktion 1 (Encoder): 13 Dreh-Encoder einrichten --------------------

// Große Dreh-Encoder: 
//           Ausgänge:   A, B, GND und 5V 
//               Lage:   eindeutig beschriftet
// Kleine Dreh-Encoder:
//            Ausgänge:   A, B und GND 
//            Lage:       Von hinten gesehen, Anschlussfahnen unten: A - rechts, B - links, GND - Mitte
//  
// Eingänge am Arduino:  Pins 2-3, 4-5, 6-7, 8-9, 10-11, 12-13, 14-15, 16-17, 18-19, 20-21,
//                            22-23, 24-25, 26-27

 int EncoderPinA [] = {2,4,6,8,10,12,14,16,18,20,22,24,26};          // Pins A der Encoder
 int EncoderPinB [] = {3,5,7,9,11,13,15,17,19,21,23,25,27};          // Pins B der Encoder
 int EncoderPos[] = {0,0,0,0,0,0,0,0,0,0,0,0,0};                     // Position der Encoder           
 int EncoderPinALast[] = {LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW};
 int n = LOW;
 int ControlChange = 176;                                            //  Midi-Kanal 1 Control-Change - Befehl 
 int ControllerNummer[] = {1,2,3,4,5,6,7,8,9,10,11,12,13};            // 13 Dreh-Encoder mit den Midi-Controller-Nummern 1 - 13
 int ControllerWert[] = {0,0,0,0,0,0,0,0,0,0,0,0,0};                 // Controller-Werte initialisieren
 int ControllerWertAlt[] = {0,0,0,0,0,0,0,0,0,0,0,0,0};
 int e = 0;                                                          // Zähler für die Encoder
 
// -------- Für Funktion 2 (Tasten): 39 Taster einrichten ----------------

// 39 einfache Taster, 2-polig:  1. Anschluss direkt an 5V
//                               2. Anschluss direkt an Arduino-Digitalpin: 28 - 53 und A1 - A11
//                               Dieser 2. Anschluss geht über einen 10K Widerstand auch auf GND.
// 39 Taster mit den Midi-Controller-Nummern 14 - 52 

int tasterPin[] = {28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,A0,A1,A2,A3,A4,A5,A6,A7,A8,A9,A10,A11,A12,A13};     // Pin Nummern der Taster
int ControlChangeT = 176;        //   Midi-Kanal 1 Control-Change - Befehl
int TControlNr[] = {14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53};
int tasterStatus[] = {LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW,LOW};
int tasterGedrueckt[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
int entprellZeit = 50;           // Zeit für Entprellung, anpassen!
unsigned long tasterZeit = 0;
int t = 0;     // Zähler für die Taster

// -------------------------------------------------------------

// =========================================================================

void setup()  // ========== Setup - Routine ================================
 { 

// ------ Für Funktion 1 (Encoder) : 13 Dreh-Encoder initialisieren  ------------------- 
   
   pinMode (EncoderPinA[e],INPUT);       // Pins A der Encoder als Input setzen
   pinMode (EncoderPinB[e],INPUT);       // Pins B der Encoder als Input setzen

/*
// ------ Für Funktion 2 (Tasten) vorbereiten ---------------------
 
   pinMode(tasterPin[t], INPUT);    // Taster Pin wird als Eingang gesetzt

// ------------------------------------------------------------------------
*/   
   Serial.begin (9600);                     // Serielle Ausgabe für Midi vorbereiten
 } 

// ======================================================================== 

void loop() // ===============  Haupt - Programm =========================
 {   
DrehEncoder();   // ------ Aufruf von Funktion 1:  Dreh-Encoder abfragen ---------

Tasten();        // ------ Aufruf von Funktion 2:  Tasten abfragen -------------
 } 
// ======================================================================== 

void DrehEncoder() //  ======== Funktion 1: 13 Dreh-Encoder abfragen ================
{  
  for (e=0;e<13;e++)
   {
   n = digitalRead(EncoderPinA[e]);                //  Dreh-Encoder abfragen
   if ((EncoderPinALast[e] == LOW) && (n == HIGH)) 
    {
     if (digitalRead(EncoderPinB[e]) == LOW) 
     {
       EncoderPos[e]--;
       ControllerWert[e] = 127;
       
       Serial.write(ControlChange);          // Ausgabe des Wertes 176 für Midi-Kanal 1
       Serial.write(ControllerNummer[e]);    // Controller-Nummer für Drehencoder 
       Serial.write(ControllerWert[e]);      // Letztes Byte des Control-Change-Befehls     
     } 
     else 
       {
       EncoderPos[e]++;
       ControllerWert[e] = 0;            // Ausgabe an Midi-Programm über Hairless Midi-Treiber
       
       Serial.write(ControlChange);          // Ausgabe des Wertes 176 für Midi-Kanal
       Serial.write(ControllerNummer[e]);    // Controller-Nummer für Drehencoder 
       Serial.write(ControllerWert[e]);      // Letztes Byte des Control-Change-Befehls            
       } 
      }   
   EncoderPinALast[e] = n;
   }
}
// ==================================================================================

// ========================= Funktion 2: 40 Tasten abfragen =====================================

void Tasten()
{
for (t=0;t<40;t++)   
{
  tasterStatus[t] = digitalRead(tasterPin[t]);  // Lesen der Tasterpins
 
  if (tasterStatus[t] == HIGH)                  // wenn der Taster gedrückt ist..
  {
    tasterZeit = millis();                     // aktualisiere tasterZeit
    tasterGedrueckt[t] = 1;                    // speichert, dass Taster gedrückt wurde
  }
 
  if ((millis() - tasterZeit > entprellZeit) && tasterGedrueckt[t] == 1)  // wenn die gewählte Zeit vergangen ist und der Taster gedrückt war.
    {
    Serial.write (ControlChangeT); 
    Serial.write (TControlNr[t]); 
    Serial.write (0);    
    tasterGedrueckt[t] = 0;                   // setzt gedrückten Taster zurück
    }
}
}
// ==================================================================================

Das ist der gesamte Code, für mehrere Dreh-Encoder und eine Menge von Schaltern.
Wer nur einen Encoder braucht, kann natürlich erst mal die Funktion “Tasten” komplett
rauswerfen, auch deren Aufruf im Hauptprogramm,
und bei den Encodern erübrigt sich dann auch das Array…

Die Anschluss-Belegung ist im Sketch dokumentiert, für den von mir vorgestellten großen “Edel-Encoder”
gelten die Werte für die 6 großen Drehencoder am Anfang der Dokumentation.

Für die Abfrage nur eines Encoders vereinfacht man also den Sketch radikal.

Man muss seinen Sketch nur um die zentralen Punkte
der Encoderabfrage herum aufbauen.

Ich habe diesen Sketch zum Teil aus Einzelelementen im Netz zusammengebaut,
was die Encoder-Abfrage angeht, da ich damit auch erst am Anfang meiner Lernkurve stehe…

HG

Sehr fein, danke.
Wenn mein Encoder da ist probier ich gleich mal.

Hallo,

der hochauflösende Hand Drehencoder gefällt mir auch. Danke für die Info. :slight_smile:

Um das zu komplettieren, die großen die ich meinte, Suchbegriff "Inkrementalgeber".
Zum Bsp.

Da habe ich ja nun doch etwas losgetreten.
Sorry Männers das ich mich erst jetzt wieder bei euch melde, also ich bin schon den ganzen Morgen am schauen nach dem passenden Inkremental Drehgeber, da ich ja den Drehgeber im Rahmen meiner Bachelorarbeit brauche ist das finanzielle eigentlich kein Problem, die Fördermittel sind vorhanden.

So langsam weiß ich ja auch was ich benötige aber was mache ich wenn ich mehr als 3 Anschlüsse am Drehgeber habe? Momentan bin ich noch am überlegen ob ich mit einem Drehgeber oder mit einem Spannbandgeber arbeiten soll. Habe jetzt ja auch schon verstanden das ich eine möglichst hohe Auflösung brauche um eine hohe Genauigkeit zu erhalten.

Meine Frage ist nun auch die Möglichkeit des "Reset" ist dies beim Arduino gegeben? Sprich ich möchte immer von einer Nulllage aus messen und müsste hierbei irgendwie das System "auf den Messwert "0" zurücksetzen.
Dies müsste ich dann doch auch programmieren können und über eine entsprechende Taste dann eben zurücksetzen, zum Beispiel wäre es mir lieb wenn sich ein kleines "Programm" programmieren ließe, welches ich dann über den Desktop öffnen kann dort eben eine Reset Taste habe und eben ein Fenster welches den Wert anzeigt.