Ich brauch eure Hilfe

Hallo Alle Entwickler,

Ich habe ein kleines Projekt und bin ganz neu in Arduino Welt.
Es geht drum, die Lage eines Fahrrads mit Hilfe von zwei BLDC-Motoren senkrecht zu stabilisieren.

dafür habe folgendes
1- einen MPU6050 (konnte schon Werte ablesen)
2- arduino due (Arbeitet Als PID-regler)
3- zwei Microcontroller der Motorregler von msp430g255, die schon angefertigt wurde

Es geht dabei, das Arduino als PID-regler bzw. als Lagerregler zu verwenden. Es muss per I2C die Werte vom Sensor auslesen, die Werte bzw. die Winkel des Fahrrads errechnen und per I2C wieder an die Motorcontroller übermitteln, um die Geschwindigkeit der Motoren hoch oder niedrig zu drehen und die Position senkrecht dabei zu behalten.

wie werdet ihr dabei umgehen, und wie wird ihr es programmieren.

Ich möchte nur wissen, ob jemand mir netterweise erklären könnte , wie ich das abgelesene Werte von mpu6050-Sensor in den PID rechnen lasse und dann per I2C weiter gebe.

*------------------------------------------------------------------------------------
                                      PID-Regler 
 -------------------------------------------------------------------------------------*/
  float Setpoint=0;
  float delta_t=0;
  float error;
  float error_alt=0;
  float t_alt=0;
  float diff_term= 0;
  float  int_term;
  float  positions;
  float agressive;
  float guard;
 // int error_value;
  int16_t Sensor_read=0;
  float Kp=200;
  float Ki=100;
  float Kd=50;

 void pid_calc(){
   delta_t = micros() - t_alt;   
   Wire.beginTransmission(address);
  // Sensor_read = digtalread(GyY);
   error = Setpoint - Sensor_read ;
   float esum = esum + (error * delta_t);                   //berechnt error integration
   float e_dif = error - error_alt;                     //berechnt error diffrentiation
   esum=0;
   int_term = esum ;                                       //berechnt itegrator term
 //--------------------------------------------------------------------
  if (delta_t != 0){                                             
       diff_term = e_dif / delta_t ;                                        //(winkel)berechnt ableitung term
        }
     else { diff_term = 0;}                                                 //winkel wird hier abglesen von sensor
  if (e_dif < agressive){
    guard = 1;
  } else { guard = 0 ;} 
  
 float y = (Kp* error/2) + (guard * Ki * int_term/256) + (Kd * diff_term) ;

 if ( y < 0 ){  //reverse
            y=0;
             }                         //Begrenzung Stellgröße

puh…also das was du erklärst macht wenig Sinn

Wie kann man Werte nicht mit PID berechnen? Wenn die Werte an einen PID-Regler übergeben werden kommt IMMER was zurück. Ein NICHT berechnen soll wohl heisen, das du dein programm nicht compilieren kannst.

Und wie hält man am Fahrrad die aufrechte Position ein mit 2 Motoren? Ich kenn nur Fahrräder die senkrecht bleiben wenn sie fahren, je schneller desdo stabiler. Dazu muss man aber nichts regeln. Willst du im Stand das Rad gegen umfallen “sichern” geht das nicht mit Motoren. Weil beim Fahrrad das Umfallen quer zur Antriebsachse erfolgt und nicht entlang der Antriebsachse

Man kann es also nicht wie ein Segway stabilisieren.

Am besten also erstmal erklären was du da machen willst und wie der mechanische Aufbau überhaupt ist. Dann dein bisheriges Programm das wohl nicht das tut was du möchtest auch posten.

Hallo,
früher sagte man "Stützräder"- Heute will er die Schwerkraft mit Motoren überlisten.
Gruß und Spaß
Andreas

chefin:
puh...also das was du erklärst macht wenig Sinn

Wie kann man Werte nicht mit PID berechnen? Wenn die Werte an einen PID-Regler übergeben werden kommt IMMER was zurück. Ein NICHT berechnen soll wohl heisen, das du dein programm nicht compilieren kannst.

Und wie hält man am Fahrrad die aufrechte Position ein mit 2 Motoren? Ich kenn nur Fahrräder die senkrecht bleiben wenn sie fahren, je schneller desdo stabiler. Dazu muss man aber nichts regeln. Willst du im Stand das Rad gegen umfallen "sichern" geht das nicht mit Motoren. Weil beim Fahrrad das Umfallen quer zur Antriebsachse erfolgt und nicht entlang der Antriebsachse

Man kann es also nicht wie ein Segway stabilisieren.

Am besten also erstmal erklären was du da machen willst und wie der mechanische Aufbau überhaupt ist. Dann dein bisheriges Programm das wohl nicht das tut was du möchtest auch posten.

Das Fahrrad wird nicht fahren es geht nur um die Reglung .und das Fahrrad nur senkrechts zu behalten
man kann sagen das Fahrrad verhält sich wie ein Segway
die Motoren haben Propellen die dabei die Schubkraft erzeugen

zweitens die Werte von dem Sensor, hier meinte ich die Winkel mit PID zu errechnen.

ich brauch tipps wie ich nur am besten tue

SkobyMobil:
Hallo,
früher sagte man "Stützräder"- Heute will er die Schwerkraft mit Motoren überlisten.
Gruß und Spaß
Andreas

Hallo
Es klingt verrückt und witzig aber es geht erst nur um die Reglung nicht mehr nicht weniger
dazu wurden Propellern auf die Motoren angebracht um die Schubkraft zu erzeugen

Hallo,
um das mal zu verdeutlichen:
Du willst über einen bestimmten Winkel die Drehzahl eines Motor regeln?

Wenn ich hinter dem stehendem Fahrrad stehe und in Fahrtrichtung schaue...
dann willst Du rechts und links vom Fahrrad einen Motor mit Propeller anbringen?
Kippt das Fahrrad nun nach rechts, dann soll der rechte Motor die Drehzahl erhöhen und mit dem Schub des
Propeller das Fahhrad wieder senkrecht stellen?
Du willst also mit einer Art von Motor-Propeller ein "Querruder" für das Fahrrad bauen?
Gruß und Spaß
Andreas

P.S.
wenn nur der PID betrieben wird, kommen dann reproduzierbare Werte?

SkobyMobil:
Hallo,
um das mal zu verdeutlichen:
Du willst über einen bestimmten Winkel die Drehzahl eines Motor regeln?

Wenn ich hinter dem stehendem Fahrrad stehe und in Fahrtrichtung schaue...
dann willst Du rechts und links vom Fahrrad einen Motor mit Propeller anbringen?
Kippt das Fahrrad nun nach rechts, dann soll der rechte Motor die Drehzahl erhöhen und mit dem Schub des
Propeller das Fahhrad wieder senkrecht stellen?
Du willst also mit einer Art von Motor-Propeller ein "Querruder" für das Fahrrad bauen?
Gruß und Spaß
Andreas

P.S.
wenn nur der PID betrieben wird, kommen dann reproduzierbare Werte?

so ist in der Tat. genau wie du so verdeutlicht hast .
ich möchte nur wissen, wie ich mit den PID-regler die ausgelesene Winkel errechne und per I2C übertrage
wie soll ich das in arduino due anstellen :frowning:

Naja... so ein Propeller muss ja dann in der Lage sein, dass Gewicht des Fahrrades zur Hälfte zu tragen (abhängig vom Winkel- ich habe jetzt den doppelten Hebelarm im Verhältnis zum Schwerpunkt angenommen)

Es gibt für Arduino genug Projekte die ein stehendes Objekt balancieren- das funktioniert dann mit rotierenden Masse- also so ähnlich wie die drehenden Räder des Fahrrads sich selbst stabilisieren... schau die mal diese Projekte an...

MaHa76:
Naja... so ein Propeller muss ja dann in der Lage sein, dass Gewicht des Fahrrades zur Hälfte zu tragen (abhängig vom Winkel- ich habe jetzt den doppelten Hebelarm im Verhältnis zum Schwerpunkt angenommen)

Es gibt für Arduino genug Projekte die ein stehendes Objekt balancieren- das funktioniert dann mit rotierenden Masse- also so ähnlich wie die drehenden Räder des Fahrrads sich selbst stabilisieren... schau die mal diese Projekte an...

danke für dein Tipps, aber die meisten Projekte mit Arduino Uno oder Mega und das bringt mir gar nichts weiter
ich weiß immer noch nicht warum wie soll ich die Winkel in den PID bringen und dann an controller per I2C übermittle

Hallo,
wenn nur der PID betrieben wird, kommen dann reproduzierbare Werte?
Und wenn ja in welchem Bereich. MinWert, MaxWert.
Gruß und Spaß
Andreas

SkobyMobil:
Hallo,
wenn nur der PID betrieben wird, kommen dann reproduzierbare Werte?
Und wenn ja in welchem Bereich. MinWert, MaxWert.
Gruß und Spaß
Andreas

ja nur PID wird betrieben. die Werte werden in MaxWert bzw die y besser gesagt bis 30000 festgelegt so ungefähr
aber in Minus und plus bereich. d.h der PID soll in der Lage sein, das zu regeln und die Drehzahl der Motoren erhöhen
dabei muss eigentlich die reproduzierbare Werte nach ne bestimmte Zeit vom Sensor ausgelesen und dann errechnet dann an die Mikrocontroller übermittelt

Hallo,
wenn Du vor mir stehen würdest, dann würde ich Dich fragen: "Hast Du etwas an
den Ohren!?"

wenn nur der PID betrieben wird, kommen dann reproduzierbare Werte?
Und wenn ja in welchem Bereich. MinWert, MaxWert.

PID in Grad:

PIDinGrad = map(PIDWert , PIDMinWert, PIDMaxWert, 0, 360)

rechnet gelieferten PIDWert in 0 bis 360 Grad.

Gruß und Spaß
Andreas

SkobyMobil:
Hallo,
wenn Du vor mir stehen würdest, dann würde ich Dich fragen: "Hast Du etwas an
den Ohren!?"

wenn nur der PID betrieben wird, kommen dann reproduzierbare Werte?
Und wenn ja in welchem Bereich. MinWert, MaxWert.

PID in Grad:

PIDinGrad = map(PIDWert , PIDMinWert, PIDMaxWert, 0, 360)

rechnet gelieferten PIDWert in 0 bis 360 Grad.

Gruß und Spaß
Andreas

Was meinst du denn mit reproduzierbare Werte ????

ich habe zwar werte vom Sensor und die werden 5ms ausglesen, dazu möchte nur von y-Ebene halt in den PID rechnen dann an die Mikrocontroller übermitteln

ich bin ja nicht so der Programmiere deswegen

Eine kleine Skizze (Freihand reicht) würde sicher nicht schaden, dann kannst du die Gesamtkonstruktion besser erläutern und deine Mitstreiter hier machen sich ein besseres Bild (im wahrsten Sinne des Wortes), was du erreichen willst und wo es im Moment genau klemmt.

Wir wissen nicht welchen Wertebereich du aus deinem Sensor bekommst, wir wissen nicht ab wann die Motoren das Fahrrad NICHT mehr halten, da ich vermute das sie das Fahrrad nicht komplett anheben können. Dieser Punkt ab dem der Motor im Volllast gerade noch die Kraft gegen die Schwerkraft aufbringt ist dein Winkelendpunkt

Mittig ist die Balance, also Null Drehzahl des Motors.

Diese Daten brauchst du um sie dem PID mitzuteilen. Woher sollen wir das alles wissen? Wir haben keine Leistungsdaten zu deinen brushlessmotoren, keine Drehzahlen, keine Luftschraubendimensionen um auch nur annähernd irgendwas zu sagen. Und wir wissen auch nicht wieviel das Rad wiegt. Und wir wissen lediglich das der gyrosensor dir einen 16 Bit Wert liefert.

Erwartest du also wirklich, das wir dir nun all das austüfteln und dann fertige Anweisungen geben wie du das aufbauen musst?

Ich würde dir vorschlagen, schliess einen Poti an und dreh den und speise diese Werte alle paar ms in den PID ein und lass dir das Ergebniss übertragen. Lerne mal, was der PID eigentlich macht. Dann finde raus, welche mechanischen Werte du einhalten musst. Motor Vollgas, welchen Winkel hat das Rad wenns dann in balance steht seitlich gekippt.

Das einzige was man sicher weis ist die Senkrechte. Und vermutlich wird man beide Motoren mit kleiner Leistung drehen lassen, das die stabilisieren. Folglich geht die Regelung erst beim Kippen auf Null bzw steigt an beim anderen Motor. In der Mitte laufen beide mit sagen wir 10% oder 20, musst mal testen, was sich als Stabil erweist.

Wenn du dann drauf sitzt oder irgendwer, passt das alles sowieso nicht mehr. Leeres Rad kann der Motor vermutlich noch stabilisieren. Selbst ein Kleinkind mit 20kg werden die Motoren nicht mehr ausbalancieren.

Wenn du Schritt für Schritt rangehst wie ich es beschrieben habe, besteht eine gute chance das wir helfen können. Aber im moment rätzeln auch alle anderen noch, was genau du baust und wie das ganze aussieht bzw welche Grenzwerte man vorgeben muss.

rpt007:
Eine kleine Skizze (Freihand reicht) würde sicher nicht schaden, dann kannst du die Gesamtkonstruktion besser erläutern und deine Mitstreiter hier machen sich ein besseres Bild (im wahrsten Sinne des Wortes), was du erreichen willst und wo es im Moment genau klemmt.

Ich möchte nur wissen, ob jemand mir nettweise erklären könnte , wie ich das abgelesene Werte von mpu6050-Sensor in den PID rechnen lasse und dann per I2C weiter gebe.
das Was.

Ich möchte nur wissen, ob jemand mir nettweise erklären könnte , wie ich das abgelesene Werte von mpu6050-Sensor in den PID rechnen lasse und dann per I2C weiter gebe.
das Was.

Das würde man dir auch gerne erklären, aber ohne das Gesamtbild zu kennen, ist das ein Herumraten.
Warum kannst du nicht

  • eine kleine Skizze mit kurzer Erläuterung machen, damit wir immer "im Bild sind"
  • die Fragen von @chefin beantworten?

Dies ist ein Forum, um Hilfe zur Selbsthilfe zu geben.
Aber dazu müssen wir präzise wissen, was genau du machen willst.

Deine letzte Antwort lässt mich weiterhin etwas konfus zurück, daher rate ich mal, damit wir weiterkommen und du bestätigst meine Annahmen oder korrigierst sie:

  1. der Gyro-Sensor liefert die "Lage-Daten" an den Arduino
  2. der Arduino soll daraus "PID"-kompatible Werte berechnen und diese
  3. auf den I2C-Bus geben, wo der PID dranhängt und der gibt dann die Korrekturwerte an die beiden Mikrocontroller, die ihrerseits per I2C angesteuert werden und dann die beiden Motoren (via DC-Motor-Treiber) drehen lassen

chefin:
Wir wissen nicht welchen Wertebereich du aus deinem Sensor bekommst, wir wissen nicht ab wann die Motoren das Fahrrad NICHT mehr halten, da ich vermute das sie das Fahrrad nicht komplett anheben können. Dieser Punkt ab dem der Motor im Volllast gerade noch die Kraft gegen die Schwerkraft aufbringt ist dein Winkelendpunkt

Mittig ist die Balance, also Null Drehzahl des Motors.

Diese Daten brauchst du um sie dem PID mitzuteilen. Woher sollen wir das alles wissen? Wir haben keine Leistungsdaten zu deinen brushlessmotoren, keine Drehzahlen, keine Luftschraubendimensionen um auch nur annähernd irgendwas zu sagen. Und wir wissen auch nicht wieviel das Rad wiegt. Und wir wissen lediglich das der gyrosensor dir einen 16 Bit Wert liefert.

Erwartest du also wirklich, das wir dir nun all das austüfteln und dann fertige Anweisungen geben wie du das aufbauen musst?

Ich würde dir vorschlagen, schliess einen Poti an und dreh den und speise diese Werte alle paar ms in den PID ein und lass dir das Ergebniss übertragen. Lerne mal, was der PID eigentlich macht. Dann finde raus, welche mechanischen Werte du einhalten musst. Motor Vollgas, welchen Winkel hat das Rad wenns dann in balance steht seitlich gekippt.

Das einzige was man sicher weis ist die Senkrechte. Und vermutlich wird man beide Motoren mit kleiner Leistung drehen lassen, das die stabilisieren. Folglich geht die Regelung erst beim Kippen auf Null bzw steigt an beim anderen Motor. In der Mitte laufen beide mit sagen wir 10% oder 20, musst mal testen, was sich als Stabil erweist.

Wenn du dann drauf sitzt oder irgendwer, passt das alles sowieso nicht mehr. Leeres Rad kann der Motor vermutlich noch stabilisieren. Selbst ein Kleinkind mit 20kg werden die Motoren nicht mehr ausbalancieren.

Wenn du Schritt für Schritt rangehst wie ich es beschrieben habe, besteht eine gute chance das wir helfen können. Aber im moment rätzeln auch alle anderen noch, was genau du baust und wie das ganze aussieht bzw welche Grenzwerte man vorgeben muss.

Hallo,
das hast du gut formuliert.
zurück zum Fragen.
1- Das Rad ist leicht und wiegt etwa 8kg und es ist leer und aus leichtem Holz
2- Sensor kann ja bis 8bit Werte zurückgeben
3- Die Motoren haben genug Power. können bis 750Umdrehungen/volt, leistung 230W
4- Propeller(Luftschraubendimensionen) haben 12X3,5 DxS

die Motoren sind schon mit mit kleiner Leistung schon zum drehen gebracht, brauche ich nur zu wissen
wie PID-Regler in Arduino programmieren kann nicht mehr nicht weniger.
Alles anders hab ich schon selber verstanden und keine muss sich rätseln

Du willst also einen Quadricopter mit 2 Motoren der nur die waagerechte Position hält, aber weder in der Höhe noch in der Richtung noch in der inklination (vorne hinten) geregelt wird.

Ich würde sagen Du mußt Dich mit Quadricopter-Theorie beschäftigen.

Grüße Uwe

rpt007:
Das würde man dir auch gerne erklären, aber ohne das Gesamtbild zu kennen, ist das ein Herumraten.
Warum kannst du nicht

  • eine kleine Skizze mit kurzer Erläuterung machen, damit wir immer "im Bild sind"
  • die Fragen von @chefin beantworten?

Dies ist ein Forum, um Hilfe zur Selbsthilfe zu geben.
Aber dazu müssen wir präzise wissen, was genau du machen willst.

Deine letzte Antwort lässt mich weiterhin etwas konfus zurück, daher rate ich mal, damit wir weiterkommen und du bestätigst meine Annahmen oder korrigierst sie:

  1. der Gyro-Sensor liefert die "Lage-Daten" an den Arduino
  2. der Arduino soll daraus "PID"-kompatible Werte berechnen und diese
  3. auf den I2C-Bus geben, wo der PID dranhängt und der gibt dann die Korrekturwerte an die beiden Mikrocontroller, die ihrerseits per I2C angesteuert werden und dann die beiden Motoren (via DC-Motor-Treiber) drehen lassen

Deine Annahme sind richtig, dazu nur

  1. der Gyro-Sensor liefert die "Lage-Daten" an den Arduino Per I2C und wurde an 0x68 definiert und kann bist 8bit Werte zurückliefern
  2. der Arduino soll daraus "PID"-kompatible Werte berechnen und diese
  3. auf den I2C-Bus geben, wo der PID dranhängt und der gibt dann die Korrekturwerte an die beiden Mikrocontroller, die ihrerseits per I2C (an 0x47 und 0x48 definiert wurden)angesteuert werden und dann die beiden Motoren (via DC-Motor-Treiber) drehen lassen.

So stimmt deine Annahme

Wie soll ich hier eine Skizze hinfügen. Ich weiß es selber dass das bisschen schwierig ist, jemand zu erklären, der das Model leider nicht sehen kann. Aber ich bin trotzdem allen dankbar für die Tipps und Erklärung .