Seite 36 von 39 ErsteErste ... 263435363738 ... LetzteLetzte
Ergebnis 351 bis 360 von 381
  1. #351
    Registriert seit
    12.02.2009
    Beiträge
    2.655

    Standard

    ick weiss, es gibt alles im netz, das dilemma ist immer nur das richtige zu finden
    aber sucher ich möchte dabei einiges verstehen, drum nutzt es wenig allzuviel herumzukopieren...
    der weg ist dass...

    erste, noch völlig wilde, MAG werte anzuzeigen hab ich erreicht, die I2C adressen also inzwischen correkt eingestellt

  2. #352
    Registriert seit
    07.10.2012
    Ort
    Mittelfranken, weit vom Wasser
    Beiträge
    2.618

    Standard

    Hallo haribo, zunächst müssen die Mag-werte gelesen und vervollständigt werden. Ich nehme an, dieser Schnipsel:
    //************************************************** *******************
    void read_mpu() //Subroutine zum Lesen des MPU Gyrometers
    // Ergibt Rohwerte ohne Korrektur
    {
    Wire.beginTransmission(MPU);
    Wire.write(0x3B); //Accel_XOUT-H
    Wire.endTransmission(false);
    Wire.requestFrom(MPU,14,true); // requests 6 Register (H+L pro Vektor)
    ax=Wire.read()<<8|Wire.read(); //0x3B (ACCEL_XOUT_H) & 0x3C (ACCEL_XOUT_L)
    ay=Wire.read()<<8|Wire.read(); //0x3D (ACCEL_YOUT_H) & 0x3E (ACCEL_YOUT_L)
    az=Wire.read()<<8|Wire.read(); //0x3F (ACCEL_ZOUT_H) & 0x40 (ACCEL_ZOUT_L)
    tmp=Wire.read()<<8|Wire.read(); // 0x41 (TEMP_OUT_H) & 0x42 (TEMP_OUT_L)
    gx=Wire.read()<<8|Wire.read(); // 0x43 (GYRO_XOUT_H) & 0x44 (GYRO_XOUT_L)
    gy=Wire.read()<<8|Wire.read(); // 0x45 (GYRO_YOUT_H) & 0x46 (GYRO_YOUT_L)
    gz=Wire.read()<<8|Wire.read(); // 0x47 (GYRO_ZOUT_H) & 0x48 (GYRO_ZOUT_L)
    }
    //************************************************** **********************

    identisch mit dem Programm, das ich hier mal reingestellt hatte, bzw. in Github steht, der tut das.
    (Du siehst an den englischen Bezeichnungen, daß ich das wo kopiert und nicht selbst geschrieben habe, ich habe für selbstgeschriebenes meist deutsche Namen vergeben.) So ganz nebenbei, ich habe mit ausschließlich globalen Variablen gearbeitet (die im Programmkopf definiert sind), weil es sowieso nicht übermäßig viele sind, und ich dann auch in anderen Programmteilen darauf zugreifen kann.
    Nach der obigen Routine stehen die 3 Mag-Werte als integer zur Verfügung.
    Der nächste Schritt ist die Normierung auf Nullpunkt und Max-wert:
    //************************************************** ***********************************
    void normiereMagnetrohwert()// die Rohwerte korrigieren (um die per
    // Normierungshilfe ermittelten
    // Korrekturwerte)
    {
    mx = mx + 0 ; //Nullpunktskorrektur mx
    mx = mx / 10; // Endgröße korrigiert
    my = my + 0 ; //Nullpunktskorrektur my
    my = my / 10 ; // Endgröße korrigiert
    mz = mz + 0 ; //Nullpunktskorrektur mz
    mz = mz / 10 ;// Endgroße korrigiert
    }
    //************************************************** ************************************
    Die Korrekturwerte mußt Du empirisch herausfinden, indem Du jeden Vektor einzeln auf 0 und Max stellst. Die hier stehenden Zahlen 0 bzw 10 sind nur Platzhalter. Zum Ausmessen nimmt man zweckmäßigerweise das Erdmagnetfeld, Winkelkorrigiert auf die lokale Inklination und Mißweisung. Dabei ist vorausgesetzt, daß der Sensor linear reagiert, was er wahrscheinlich nicht tut. Will man das genau machen, z.B. für eine numerische Anzeige, könnte man das per Look-Up-Table machen, und für jedes Grad einzeln einen Korrekturwert einführen. Die Speichergröße des Arduino würde das hergeben. Ich habe diese Unlinearitäten einfach ignoriert und mich mit der simplen Addition/Multiplikation zufriedengegeben, es wäre sonst richtig viel Arbeit gewesen.
    Viele Grüße
    nw
    Geändert von sucher (25.05.2020 um 18:45 Uhr) Grund: korrektur
    Πάντα ῥεῖ (*)
    * Man kann nicht zweimal auf dem selben Fluß fahren.

  3. #353
    Registriert seit
    12.02.2009
    Beiträge
    2.655

    Standard

    na du machst mir spass sucher, englisch ist deine stärke not... also du hast den falschen schnipsel erwischt, lies den schnipsel nochmal durch er handelt von acc-akuts, tempos und gyros aber eben nicht von teslas magneten

    macht aber nichts, denn du hast mich trotz deiner verwirrungsversuche drauf gebracht die mag-werte als einheitsvektor zu kalibrieren und ebenso aufzufassen, dann klappts auch mit den winkeln,

    ich muss noch die achsen sortieren gemeinerweise sind sie nicht gleich ausgerichtet wie die vom beschleunigungs-chip ... folgen aber trotzdem der rechten hand regel

  4. #354
    Registriert seit
    07.10.2012
    Ort
    Mittelfranken, weit vom Wasser
    Beiträge
    2.618

    Standard

    Hallo haribo, ja Du hast recht, es ist die falsche Subroutine. Die Richtige ist jedoch nahezu identisch, nur die Varablennamen sind anders. ( Der Kommentar ist von mir und ist in deutsch,Flüchtigkeitsfehler von mir!).
    Du wirst die Beschleunigungsvektoren ebenso brauchen, weil die hinterher in die Formel für die Kursberechnung rein müssen.

    Neben der schon angesprochenen Normierung (und Linearisierung, wenn Du willst) wirst Du auch feststellen, daß die Werte gewaltig rumzappeln. Ein Programmierprofi (die es hier ja auch gibt) wird als nächstes schulmäßig ein Kalman-Filter utilisieren. Ich habe viele, viele Stunden damit verbracht sowas in Gang zhu bringen, ich habe es nicht hinbekommen, trotz vieler Beispiele im Netz. Ein Grund dürfte sein, weil bestimmt ein Dutzend zugehöriger include-Files gleichen Namens im Netz herumschwirren, die aber offensichtlich unterschiedlich sind. Ich habe mich daraufhin entschlossen, den Weg des geringsten Widerstandes zu gehen und wenig schulmäßig den schlichten Durchschnitt der gelesenen Werte zu bilden, es funktioniert schon mit 10 Samplen, die Werte stehen stocksteif! Der Arduino ist so schnell, und der Speicherplatz so groß, es würde vermutlich mit 100 Werten ganz genauso gehen.

    Hier nochmal die Routine für die Mag-Werte:
    //************************************************** *************************************


    void read_mag() // Subroutine zum Lesen der Magnetvektoren (nach erfolgter Initialisierung)
    {
    Wire.beginTransmission(MAG);
    Wire.write(byte(0x03));
    Wire.endTransmission();
    Wire.requestFrom(MAG,6);
    if(Wire.available()<=6)
    {
    mx=Wire.read()<<8;
    mx|=Wire.read();
    mz=Wire.read()<<8;
    mz|=Wire.read();
    my=Wire.read()<<8;
    my|=Wire.read();
    }

    }
    //************************************************** **************************************

    Das Glätten per Durchschnitt:
    //************************************************** ************************************
    void glaetteMagnetrohwert()
    { // 1.) Array beschreiben
    arraymx[iM] = mx; //Array entsprechend iM mit Magnetwert x beschreiben
    arraymy[iM] = my; //Array entsprechend iM mit Magnetwert y beschreiben
    arraymz[iM] = mz; //Array entsprechend iM mit Magnetwert z beschreiben
    iM=iM+1; // Zeiger für den nächsten Durchlauf inkrementieren

    if (iM>10)

    {
    iM=0; // Array voll, Zeiger zurücksetzen
    }

    //2.) Array lesen
    mx=(arraymx[0]+arraymx[1]+arraymx[2]+arraymx[3]+arraymx[4]+arraymx[5]+arraymx[6]+arraymx[7]+arraymx[8]+arraymx[9]+arraymx[10])/10; //Durchschnitt aus 10 Werten
    my=(arraymy[0]+arraymy[1]+arraymy[2]+arraymy[3]+arraymy[4]+arraymy[5]+arraymy[6]+arraymy[7]+arraymy[8]+arraymy[9]+arraymy[9])/10; //Durchschnitt aus 10 Werten
    mz=(arraymz[0]+arraymz[1]+arraymz[2]+arraymz[3]+arraymz[4]+arraymz[5]+arraymz[6]+arraymz[7]+arraymz[8]+arraymz[9]+arraymz[9])/10; //Durchschnitt aus 10 Werten
    //Nach dieser Routine sind die Kompassrohwerte mx, my, mz beruhigt

    }
    //************************************************** *************************************
    Die Spezialität dabei ist, in der Initialisierung wird das Array mit 0 belegt, das bedeutet, der Wert ist von Anfang an, auch beim ersten Durchlauf gültig!

    Damit Du nicht fragen mußt, meine Variante der Kursberechnung:
    //************************************************** **************************************
    void berechnekurs() //Aus den Rohdaten für Beschleunigung und Magnetfeld wird der
    { // Tiltkompensierte Kurs berechnet.

    float xh,yh,ayf,axf;

    ayf=ay/57.0;//Convert to rad

    axf=ax/57.0;//Convert to rad

    xh=mx*cos(ayf)+my*sin(ayf)*sin(axf)-mz*cos(axf)*sin(ayf);

    yh=my*cos(axf)+mz*sin(axf);



    kurs=atan2((double)yh,(double)xh) * (180 / PI) -90; // angle in degrees

    if (kurs>0){kurs=kurs-360;}

    kurs=360+kurs;
    }



    //************************************************** **************************************
    Diese Formel ist aus dem Netz abgeschrieben, die Tiltkompensation funktioniert NICHT zufriedenstellend. Ich habe bestimmt ein Dutzend nahezu identischer Varianten durchprobiert, mit dieser bin ich noch am weitesten gekommen.
    Viel Spaß!
    nw
    Πάντα ῥεῖ (*)
    * Man kann nicht zweimal auf dem selben Fluß fahren.

  5. #355
    Registriert seit
    12.02.2009
    Beiträge
    2.655

    Standard

    kleinigkeit:
    if (iM>10) muss heissen: if (iM>9) weil null bis neun schon zehn ergibt
    grus haribo

  6. #356
    Registriert seit
    07.10.2012
    Ort
    Mittelfranken, weit vom Wasser
    Beiträge
    2.618

    Standard

    Hallo haribo, ja, Du hast schon wieder recht!, zu meiner Entschuldigung kann ich sagen, die Kopien sind aus einer frühen Version, auf die wirklich laufende Variante habe ich aktuell keinen Zugriff, was ich hier zum Besten gebe, zitiere ich aus dem Gedächtnis, und es ist bald 3 Jahre her, daß ich das programmiert habe.
    Viele Grüße
    nw
    PS: hier noch die Deklarierung des Arrays aus dem Programmkopf:n (damit nicht wieder wer glaubt, ich hätte die Deklarierung vergessen.)
    int16_t arraymx[11]; // Array zum Speichern von 10 Magnetrohwerten x für Glättung
    int16_t arraymy[11]; // Array zum Speichern von 10 Magnetrohwerten y für Glättung
    int16_t arraymz[11]; // Array zum Speichern von 10 Magnetrohwerten z für Glättung
    Πάντα ῥεῖ (*)
    * Man kann nicht zweimal auf dem selben Fluß fahren.

  7. #357
    Registriert seit
    12.02.2009
    Beiträge
    2.655

    Standard

    fals du nochmals ne variante testen möchtest... uf eigene gefahr
    klar könnte man pitch weglassen, es ist aber tatsächlich einfacher es drin zu lassen

    { // mein erster schreibtisch versuch der tiltkompensation, haribo mai 20
    // achtung da können vorzeichenfehler drin sein, die achslagen sind und bleiben tricky

    double PI = 4.0 * atan (1.0);
    float ax, ay, az ;
    float xh , yh , pitch , roll ;


    pitch = atan ( az / ay );
    roll = atan ( az /ay ); // roll nur aus ay zu berechnen dürfte ggfls. der hauptgrund deiner ungenauigkeit gewesen sein

    xh = mx * cos (pitch) + mz * sin (pitch) ;
    yh = mx * sin (pitch) * sin (roll) + my * cos (roll) –mz * sin (roll) * cos (pitch);

    kurs=atan2 (xh , yh) * (180 / PI); // x und y vertauscht dafür die minus 90 weg , ist ein versuch
    if (kurs<=0){kurs=kurs+360;} // <= sonst gibt es den kurs null der soll aber 360 sein
    }

    ich werde aber pitch und roll aus gyro daten berechnen und nur mit acc daten stabilisieren
    auch kurs bzw abweichung-kurs wird aus gyrodaten berechnet und nur mit mag daten stabilisiert werden, denke ich

    atan2 für den kurs finde ich ne gute idee, wens in "C" funktioniert, das hab ich noch nie probiert

    mein kompass hat derzeit nen noch nen fehler von ~25°...

  8. #358
    Registriert seit
    07.10.2012
    Ort
    Mittelfranken, weit vom Wasser
    Beiträge
    2.618

    Standard

    Hallo haribo, danke, ich werde es bei Gelegenheit testen. Respekt, daß Du das so schnell auf die Beine gestellt hast, und offensichtlich alles selbst geschrieben?

    Leider komme ich aktuell nicht an das Schiff und damit an den Autopiloten ran, zudem sehe ich gerade wieder meine Felle (meinen Flug) davonschwimmen. Wenn kein Wunder geschieht, muß ich nochmal 4 Wochen hierbleiben.
    Ich meine, mein Versuch war besser als 25° Fehler, das würde aber garnichts ausmachen, solange man den Kurs nicht anzeigt. Es bedeutet lediglich, daß die Regelgenauigkeit nicht in jeder Richtung gleich ist. Was man um jeden Preis vermeiden muß, sind Schleifen bzw. Epicyclen, den da würde jede Regelung verückt spielen, Ich hatte das zuerst, aber durch sorgfältige Normierung der Rohwerte habe ich das herausbekommen. Nächste Steigerung wäre die Look-Up-Table geworden, aber es ging auch ohne.

    Für den nächsten Schritt empfehle ich, unbedingt einen Versuchsaufbau zu erstellen. Dieser sollte einen möglichst großen Motor Als Stellglied und ein Potentiometer als Rückmeldung bzw. Ruderlagegeber beeinhalten. Im Idealfall die Originalanordnung im Schiff. Ich hatte als Motor einen Stellmotor aus einem KFZ, also etwa sowas: https://www.ebay.de/itm/JCF63R-Mini-...0AAOSwVPBeljIU , das mechanisch mit einem Potentiometer verbunden.

    Im Prinzip ist das genau die Anordnung wie in dem Modellbauservo, der den meisten Arduino-Kits beiliegt. Wenn man wollte könnte man das mit den zugehörigen Routinen aus dem Arduino-Playground entsprechend nutzen. Ich habe mich dagegen entschieden.

    Meine Erfahrung aus dem Sondermaschinenbau sagt, der Leistungstreiber muß reichlich Reserve haben, also 5* den Maxstrom des Motors. Er darf nicht schlappmachen, auch wenn der Motor länger Zeit im Stillstand bei Full Power festgehalten wird. Der Motor aus dem Beispiel hat 5A Nennstrom, dann sollte der Leistungstreiber mindestens 25A können, ohne nennenswert warm zu werden. Natürlich hängt das auch von der Mechanik in Deinem Schiff ab.

    Erst wenn der Motor mit variabler Drehzahl(PWM!) rotiert, das Ruderlagepoti sauber die Endschalter simuliert, und die Fehlerbehandlung klappt (Unterbrechung/Kurzschluß/Überlast), kommt die eigentliche Regelung dran.
    Viel Glück
    nw
    Πάντα ῥεῖ (*)
    * Man kann nicht zweimal auf dem selben Fluß fahren.

  9. #359
    Registriert seit
    09.01.2016
    Beiträge
    1.425

    Standard

    Zitat Zitat von haribo Beitrag anzeigen
    fals du nochmals ne variante testen möchtest... uf eigene gefahr
    klar könnte man pitch weglassen, es ist aber tatsächlich einfacher es drin zu lassen
    ...
    Hallo,

    wie wäre es, genau die Diskussion aufs Github zu legen?
    Dann wäre jede Stufe der Änderung zukünftig dauerhaft nachvollziehbar.

    Hier findet etwas später doch kein Lebender mehr in einem vernünftigen Zeitrahmen einen Zusammenhang heraus.


    Peter

  10. #360
    Registriert seit
    12.02.2009
    Beiträge
    2.655

    Standard

    ich hab endlich verstanden was inklination bedeutet und wie schräg das durch mein zimmer läuft (fast -75°, das wusste ich nicht)
    damit war die mag-calibrierung nun gut zu bewerkstelligen
    nein ich hab das auch nicht selbst geschrieben, aber die kalibrierungen alle selber gemacht

    ---> besser als +/-5° noch ohne irgend einen filter etc, vermutlich hat der chip auch für den mag eingebaute tiefpass filter...

    motor wird dir gefallen, ich nehm erstmal einen 12V akkuschrauber, evtl einen 10er poti um ne kleine winde zu bauen
    regler weiss ich noch nicht, am coolsten wäre es den schrauber direkt mittels zweier servos zu schalten denn er hat jetzt schon nen BUK454-60H mosfet, ich hab auch dass noch nie gemacht aber was spricht dagegen mit nem regler diesen ausreichen dimensionierten mosfet anzusteuern?

    das reicht kraftmässig, mein schiffchen wiegt <2to, und das ruder mit pinne ist ausgewogen

    moin k lauer,
    githupe bitte noch nicht, es gibt wirklich schon jetzt zu viele schräge muster, es ist wirklich inzwischen ein problem den mist von guten beispielen zu unterscheiden

Ähnliche Themen

  1. Open Source Navigation
    Von macjena im Forum Technik & Elektronik
    Antworten: 5
    Letzter Beitrag: 22.03.2011, 12:51
  2. Rettet Jeantex - Gründung einer Genossenschaft
    Von Wladimir im Forum Fragen, Antworten & Diskussionen
    Antworten: 0
    Letzter Beitrag: 01.03.2010, 21:06
  3. Die böse Open Source Community
    Von Contrast33 im Forum Klönschnack
    Antworten: 2
    Letzter Beitrag: 19.05.2009, 20:58
  4. Wer hat Erfahrung mit GARMIN MAP-SOURCE: world map
    Von rolf im Forum Technik & Elektronik
    Antworten: 1
    Letzter Beitrag: 29.05.2001, 16:52

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •