rustyoldguy
Mitglied
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
nun dazu riemen.cpp
Jetzt main.cpp
menuefrage.h
menuefrage.cpp
jetzt winkelfunktionen.cpp
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:
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:
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
Code:
#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
Code:
#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;
}
Code:
// 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
Code:
#ifndef MENUEFRAGE_INC_
#define MENUEFRAGE_INC_
#include <iostream>
#include <string>
int MenueFrage(void);
#endif
Code:
#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;
}
Code:
#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:
Zuletzt bearbeitet von einem Moderator: