Kleines Beispiel zur Berechnung der mittleren Riemenlänge bei Riementrieben mit Ableitung der Formel

[rustyoldguy]

Hallo Umschüler und Konsorten!

Wer schon einmal mit Riementrieben zu tun hatte hat sich schon einmal gefragt, wie denn eigentlich die
Konstrukteure auf die richtige Riemenlänge kommen, sei es jetzt Zahnriemen oder Keilriemen.
Da man im Web darüber fast keine Abhandlung findet, hier eine kleine Einleitung mit einem Beispiel als
Programm. Also ein klitze klein wenig Mathematik.

Zunächst müssen wir den Umschlingungswinkel des Riemenrades mit dem kleineren Durchmesser finden.
Davon leiten sich alle anderen Größen ab.

Dm= Durchmesser des größeren Riemenrades
dm= Durchmesser des kleineren Riemenrades
A= Achsabstand

Zunächst dazu einige Zeichnungen:

lges Wie daraus ersichtlich lässt sich der Umschlingungswinkel des kleineren Riemenrades mit

errechnen.

Nehmen wir uns ein Beispiel.

Dm soll 105mm und dm soll 46 mm sein.
Der Achsabstand A ist in unserem Beispiel 140

Doch bevor wir diese Formel verwenden, werden wir uns Zeit für eigene Analysen nehmen.
Zuerst die Berechnung des Umschlingungswinkel β;


rdif = (Dm-dm) / 2) = 29,5 mm
β = 2 * arccos(rdif / A) =2 * 77.83578551 = 155,671571026538° Grad beim kleineren Riemenrad



Dann wird der Winkel des größeren Riemenrades berechnet:

360° - β = 204,328428973462° Grad

Winkeldifferenz der Linie vom Achsmittelpunkt zum Berührungspunkt der Tangente am Kreis
zur senkrechten Koordinatenachse der Zeichnung:

α = 90° - 77.83578551° = 12.16421449° == Wichtig zur späteren Berechnung und der abgeleiteten Formel!

Somit beträgt die Länge eines der schräg liegenden Riementeile

sin(77.83578551°) * 140 = 136.8566769mm
Ergibt wiederum 273.7133538 mm der beiden geraden Teile.

Könnte man bei unterschiedlichen Durchmessern, sprich Übersetzungsverhältnis ungleich 1 : 1 mit den Lehrsatz des Pythagoras machen.


Der Umfang eines Kreise errechnet sich aus d * π
somit ist

U1 = ((dm * π) * β) / 360
U1 = ((46 * π) * 156.2020591) / 360
U1 = 62,4905737218017 mm


Nun Achtung: Bei der großen Scheibe muss 180° + 2* α gerechnet werden!


U2 = ((Dm * π) * (360- β)) / 360
U2 = ((105 * π) * 203.7979409) / 360
U2 = 187,22570165325 mm

lges = 2 * 136.856676 mm + 62,490573 mm + 187,225701 mm
lges = 523,429629086558 mm


Die errechnete Länge des Riemens wäre lges = 523.429629 mm

l1 = A * sin ((β / 2)
l1 = 136.8566769mm

Nun zum code.
Zuerst der Header riemen.h

#ifndef RIEMEN_INC_
#define RIEMEN_INC_ 1

#include <iostream>
#include <iomanip>
#include <math.h>

double radtograd(double boma);
double bogenmass(double grad);
double get_tanwert(double lfatan);
double grad_sin(double grad);
double grad_cos(double grad);
void clpuf(void);

#define RIEMENLAENGE 1
#define DREHZAHLEN 2


extern struct riemenantrieb{
double A;
double gd;
double kd;
double i;
double rgd;
double rkd;

double grad;
double boma;
double alpha;
double Umschlingungswinkel;
double beta;
double l1;
double Ua;
double Ub;
double lx;
double xu;

double n1; // Drehzahl kd
double n2; // Drehzahl gd

} rit;

double riemenlaenge(struct riemenantrieb *rit);
void ShowErgebnisse(struct riemenantrieb rit);
int get_diameters(struct riemenantrieb *rit, int berechnungsart);
int get_Achsabstand(struct riemenantrieb *rit);
int get_Drehzahl(struct riemenantrieb *rit);
void calc_n_und_Dd(struct riemenantrieb *rit);

#endif

nun dazu riemen.cpp

#include "riemen.h"

double riemenlaenge(struct riemenantrieb *rit)
{
  rit->rgd = rit->gd / 2;
  rit->rkd = rit->kd / 2;
  rit ->i = rit->gd / rit->kd;

  // Bei kleinen Riemenrad  Umschlingungswinkel englisch: wrap angle
rit->Umschlingungswinkel = 2* radtograd(acos(((rit->gd-rit->kd) /(2* rit->A))));

  rit->alpha = (180 - rit->Umschlingungswinkel) / 2;             // Umschlingungswinkel kleines Riemenrad
  rit->beta = 360 - rit->Umschlingungswinkel;                    // Umschlingungwinkel grosses Riemenrad
  rit->Ua = ((rit->kd * M_PI) * rit->Umschlingungswinkel) / 360; // Umschlingungsumfang kleines Riemenrad
  rit->Ub = ((rit->gd * M_PI) * rit->beta) / 360;                // Umschlingungsumfang grosses Riemenrad


  rit->l1 = rit->A * (grad_sin(rit->beta / 2));  // EIN Teilstueck l1 berechnen

  rit->lx = rit->Ua + rit->Ub+ (2* rit->l1);   // Alle 4 Teile zusammenrechnen

  // Formel aus dem Tabellenbuch --->> Formel stimmt!
rit->xu = ((M_PI * (rit->gd + rit->kd)) / 2) + ( 2 * rit->A * grad_sin(rit->beta / 2)) + (((M_PI * rit->alpha) / 180)* (rit->gd - rit->kd));

  return rit->lx;
}

void ShowErgebnisse(struct riemenantrieb rit)
{
std::cout << "\nD=" << rit.gd << "  d=" << rit.kd << "  A=" << rit.A << std::endl;
std::cout << "Uebersetzungsverhaeltnis i = Dm/dm =" << rit.i << std::endl;
std::cout << "Umschlingungswinkel dm= " << std::setprecision(9) << rit.Umschlingungswinkel << "° Grad" << std::endl;
std::cout << "Umschlingungswinkel Dm= " << std::setprecision(9) << rit.beta << "° Grad" << std::endl;
std::cout << "alpha........= " << std::setprecision(9) << rit.alpha << std::endl;
std::cout << "l1...........= " << std::setprecision(9) << rit.l1 << std::endl;
std::cout << "Mittlere Riemenlaenge:" <<  std::endl;
std::cout << "xu...........= " << std::setprecision(9) << rit.xu << std::endl;
std::cout << "lx...........= " << std::setprecision(9) << rit.lx << std::endl;
}
// Loesche den Tastaturpuffer 'Essensreste aufraeumen'
void clpuf(void)
{
while (getc(stdin) != '\n')
    ;
}


int get_diameters(struct riemenantrieb *rit, int berechnungsart)
{
int fehlertest = 0;

if(berechnungsart == 2)
std::cout << "Drehzahlberechnung: Bitte nur einen Durchmesser zur desser Berechnung auf Null setzen!" << std::endl;
std::cout << "Dm grosses Riemenrad: ";
std::cin >> rit->gd;
std::cout << "dm kleines Riemenrad: ";
std::cin >> rit->kd;

    if(berechnungsart == 1)
     {
       if(rit->gd <= 0)
        {
         std::cout << "Fehlerhafte Eingabe Dm grosses Riemenrad" << std::endl;
          fehlertest = 8;
        }
        if(rit->kd <= 0)
         {
          std::cout << "Fehlerhafte Eingabe dm kleines Riemenrad" << std::endl;
           fehlertest = 8;
        }
      }
   else if(berechnungsart == 2)
    {
      if((rit->gd <= 0) && (rit->kd <= 0))
        {
         std::cout << "Fehlerhafte Eingabe beider Durchmesser" << std::endl;
          fehlertest = 8;
        }
        if(rit->kd < 0)
         {
          std::cout << "Fehlerhafte Eingabe dm kleines Riemenrad < 0" << std::endl;
           fehlertest = 8;
         }
        if(rit->gd < 0)
         {
          std::cout << "Fehlerhafte Eingabe dm grosses Riemenrad < 0" << std::endl;
           fehlertest = 8;
         }
     }

return fehlertest;
}

int get_Achsabstand(struct riemenantrieb *rit)
{
int fehlertest = 0;
std::cout << "Achsabstand.........: ";
std::cin >> rit->A;
if((rit->A <= 0) || (rit->A <= ((rit->gd +rit->kd) / 2)))
  {
   std::cout << "Fehlerhafte Eingabe Achsabstand: kleiner/gleich (Dm + dm) / 2" << std::endl;
   fehlertest = 8;
  }
return fehlertest;
}

int get_Drehzahl(struct riemenantrieb *rit)
{
int fehlertest = 0;

    std::cout << "Drehzahl n1 an dm: ";
    std::cin >> rit->n1;
    std::cout << "Drehzahl n2 an Dm: ";
    std::cin >> rit->n2;

    if((rit->n1 <= 0) && (rit->n2 <= 0))
     {
      std::cout << "n1 an dm= " << rit->n1<< std::endl;
      std::cout << "n2 an Dm= " << rit->n1<< std::endl;
      std::cout << "Fehlerhafte Eingabe Drehzahl: Bitte eine Drehzahlangeben" << std::endl;
      fehlertest = 8;
     }

return fehlertest;
}

void calc_n_und_Dd(struct riemenantrieb *rit)
{
         // Antriebsformel: n1* dm = n2 * Dm
         // Antriebsformel: rit.n1* rit.kd = rit.n2 * rit.gd
         // Abschnitt aus Drehzahlen Durchmesser berechnen
         if ((rit->n1 > 0) && (rit->n2 > 0) && (rit->kd > 0))    // Aus n1, n2, d1  ->>d2
         {
          rit->gd = (rit->n1* rit->kd) / rit->n2;
         }
         if ((rit->n1 > 0) && (rit->n2 > 0) && (rit->gd > 0))    // Aus n1, n2, d2  ->>d1
         {
          rit->kd = (rit->n2* rit->gd) / rit->n1;
         }
         // Abschnitt aus Drehzahlen und Durchmesserangaben fehlende Angaben berechnen
         // Aus dm, Dm und n1  berechne n2
         if ((rit->kd > 0) && (rit->gd > 0) && (rit->n1 > 0))    // Aus d1, d2, n1  ->>n2
         {
          rit->n2 = rit->n1* rit->kd / rit->gd;
         }
         // Aus dm, Dm und n2  berechne n1
         if ((rit->gd > 0) && (rit->gd > 0) && (rit->n2 > 0))    // Aus d1, d2, n2  ->>n1
         {
          rit->n1 = rit->n2 * rit->gd / rit->kd;
         }
         // Aus dm, n2 und n1  berechne Dm
         if ((rit->kd > 0) && (rit->n1 > 0) && (rit->n2 > 0))    // Aus d1, n1, n2  ->>d2
         {
          rit->gd = rit->n1 * rit->kd / rit->n2;
         }
         // Aus Dm, n2 und n1  berechne dm
         if ((rit->gd > 0) && (rit->gd > 0) && (rit->n1 > 0))    // Aus d2, n1, n2  ->>d1
         {
          rit->kd = rit->n2 * rit->gd / rit->n1;
         }
         rit->i = rit->n1 / rit->n2;
}

Jetzt main.cpp

// riemenlaenge4 Berechung der mittleren Riemenlaenge eines Riementriebes
#include "riemen.h"
#include "menuefrage.h"

int main(int argc, char **argv)
{
riemenantrieb rit;

int quest = 8;

do
switch(quest)
{
  default:
       std::cout << "\nRiemenantrieb, Berechnung der mittleren Riemenlaenge" << std::endl;
       std::cout << "Programmende.................0" << std::endl;
       std::cout << "Riemenlaenge Beispiel........1" << std::endl;
       std::cout << "Riemenlaenge eigene Angaben..2" << std::endl;
       std::cout << "Drehzahl berechnen...........3" << std::endl;
       quest = MenueFrage();

     break;


  case 0:
       std::cout << "Programm beendet" << std::endl;
       return 0;

  case 1:
        rit.A = 140;   // Wellenabstand
        rit.gd = 105;  // Durchmesser der großen Keilriemenscheibe
        rit.kd = 46;   // Durchmesser der kleinen Keilriemenscheibe
         riemenlaenge(&rit);
        ShowErgebnisse(rit);
           quest = 8;
      break;

  case 2:
        std::cout << "Berechnung der mittleren Riemenlaenge" << std::endl;
        quest = get_diameters(&rit, RIEMENLAENGE);
        if(quest != 0) break;
        quest = get_Achsabstand(&rit);
        if(quest != 0) break;
        riemenlaenge(&rit);
        ShowErgebnisse(rit);
        quest = 8;
      break;

   case 3:
        std::cout << "Berechnung der Drehzahl" << std::endl;
        get_diameters(&rit, DREHZAHLEN);
        quest = get_Drehzahl(&rit);
        if(quest != 0) break;
        calc_n_und_Dd(&rit);

        std::cout << "\nD=" << rit.gd << "  d=" << rit.kd << std::endl;
        std::cout << "n2=" << rit.n2 << "  n1=" << rit.n1 << std::endl;
        std::cout << "Uebersetzungsverhaeltnis i=" << rit.i << std::endl;

        quest = 8;
      break;


}while(quest != 0);
    return 0;
}

menuefrage.h

#ifndef MENUEFRAGE_INC_
#define MENUEFRAGE_INC_

#include <iostream>
#include <string>

int MenueFrage(void);

#endif

menuefrage.cpp

#include "menuefrage.h"
#include "riemen.h"

int MenueFrage(void)
{
int frage = 18, i;
std::string wastun = "";
std::string erge[16] = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10","11","12","13","14","15"};

std::cout << std::endl << "Ihre Wahl: ";
std::cin >> wastun; // frage

for (i = 0; i < 16; i++)
  {
   if (wastun.compare(erge[i]) == 0)
   {
    frage = i;
    break;
   }
}
clpuf();

return frage;
}

jetzt winkelfunktionen.cpp

#include "riemen.h"

// Wandelt Bogenmass in Grad um
double radtograd(double boma)
{
double grad, pi = M_PI;

grad = ((boma * 180) / pi);
return grad;
}

// Wandelt grad in Bogenmass um
double bogenmass(double grad)
{
double boma, pi = M_PI;

boma = (grad * pi)  / 180;
return boma;
}

double get_tanwert(double lfatan)
{
double boma, grad;
boma = atan(lfatan);
grad = radtograd(boma);

return grad;
}

double grad_sin(double grad)
{
double boma, sinwert;

boma = bogenmass(grad);
sinwert = sin(boma);

return sinwert;
}

double grad_cos(double grad)
{
double boma, coswert;

boma = bogenmass(grad);
coswert = cos(boma);

return coswert;
}

Mir geht es darum vorab eine Erklärung zu liefern, wie denn eine solche Formel zu Stande kommt.

Auf die Frage hin:
"Wie kommen Sie gerade auf diese mittlere Riemenlänge?"

Sollte man schon etwas parat haben. Kann im Beruf zur Stolperfalle werden.

Diese Formel gilt natürlich nur, wenn keine Spannrollen verwendet werden.
Mit Riementrieben lassen sich billig erschütterungsfrei und mit großen Achsabständen Antriebe realisieren.
Etwa bei Drehmaschinen. So werden eventuelle kleinere Unregelmäßigkeiten beim Lauf des Antriebsmotors
von der getriebenen Achse weitgehend entkoppelt.
Formen sind etwa Flachriemen, Keilriemen, Rundriemen (z.B. Uhrmacherdrehbänke, Nähmaschinen), Zahnriemen.

Früher verwendete man im Automobilbau bei der Steuerung der Nockenwelle noch Ketten. Damals war aber die
Herstellung noch nicht so ausgereift wie heute. Da die Steuerzeiten mit Ketten genauer sind, gingen einige Hersteller
bei manchen Modellen wieder zur Kette. Etwa bei einem Ford Fiesta von 2005 mit 1300ccm und 70 PS.

Bei einigen Motorradmodellen sind ebenso Steuerketten vorhanden(Meine YZF 600 Thundercat). Nur einige
Besondere Modelle, so weit ich weis zum Beispiel einige von Ducati, haben eine Königswelle.
Diese halte ich nach wie vor für High-Tech.

Damals wie heute.

Hier übrigens einige Fotos von einer Keilriemenscheibe und einer Flachriemenscheibe bei der
Vermessung auf einer Koordinatenmessmaschine:

 

[lord_haffi]

Cool, mach doch 'ne Ressource draus

 

[rustyoldguy]

Mal schaun was ich sonst noch rein stellen könnte.