Seite 33 von 39 ErsteErste ... 233132333435 ... LetzteLetzte
Ergebnis 321 bis 330 von 381
  1. #321
    Registriert seit
    07.10.2012
    Ort
    Mittelfranken, weit vom Wasser
    Beiträge
    2.589

    Standard

    Hallo haribo, ist schonmal ziemlich gut. Das Display mit I2C kann parallel zum Sensor an den I2C Bus angeschlossen werden (solange sich die Adressen nicht beißen). Das Display ist zum Debuggen beinahe besser als der serielle Monitor. Also Display per I2C anschließen. In den Beispielen im IDE gibt es unter New LCD ein kleines Programm "I2C Hello world". Das reinladen und testen. Probleme kann es geben mit der Größe (Zeilenzahl/Zeilenlänge): anpassen! Erstmal damit spielen, bis der Magnesensor da ist, erst dann geht es mit dem AP weiter. Inzwischen mal den I2C-Scanner testen, wie der die Adressen des Display darstellt. Auch wenn es Schwierigkeiten mit den I2C-Adressen gibt (Nicht jedes Display entspricht den Vorgaben!). Wenn Du das Display beherrschst, gehts weiter.

    Wie ich es gemacht habe: Grundsätzliche Konstruktion eines in Entwicklung begriffenen C-Programms:
    Ganz oben Titel z.B. Autopilot Maxsimplex, + Versionsnummer (ist auch der Filename)
    Nächste Zeile: Was das Ganze am Ende sein soll.
    Nächste Zeilen (alte bleiben stehen, neue untendran) was jeweils neu ist, geht oder geht nicht.
    Nächste Zeilen: Includes, zB.
    #include <Wire.h>
    #include <LiquidCrystal_I2C.h>
    Alte, auch nicht gebrauchte können erstmal stehenbleiben, erst wenn der Speicherplatz zuende geht, aussieben (wird nicht vorkommen). Immer reichlich Kommentare dazuschreiben, für Dummies!!!!!!
    Definitionen, alle, auch die später hinzukommenden da untereinander reinschreiben, nach Subrotines geordnet, Kommentare nicht vergessen!!!!
    Dann Subroutines (wirst Du vorläufig noch nicht haben)
    Erst dann setup
    loop

    Mit dem Konzept gleich anfangen!
    Beispiel:
    /* Autopilot Maxsimplex
    In der einfachsten Version hat der AP als einziges Bedienelement einen Ein/Aus-Schalter.
    Man bringt das Schiff manuell auf den gewünschten Kurs und schaltet den AP ein. Dieser
    hält den Kurs fortan nach seinem Magnetkompaß.
    Will man den Kurs ändern, schaltet den Ap aus, bringt das Schiff manuell auf den neuen Kurs,
    und schaltet den Ap wieder ein.

    */
    #include<Wire.h> // Library für den I2C-Bus
    const int MPU=0x68; // I2C address of the MPU-6050
    const int MAG=0x1E; // I2C Adresse des Magnetometers 7bit Adresse
    const int rudermaschinestrompin = A3;//Stromsensor für die Rudermaschine liegt an Analogeingang A3 (Pin 26)
    int rudermaschinestrom = 0; // Aktueller Wert der Stromaufnahme der Rudermaschine
    const int kupplungstrompin = A6; //Stromsensor für die Kupplung liegt an Analogeingang A6 (Pin 19)
    int kupplungsstrom = 0; //Aktueller Wert der Stromaufnahme der Kupplung
    const int ruderlagepin = A7; // Ruderlagepotentiometer ist an Analogeingang 7 (Pin 22)
    int ruderlage = 0; // Aktueller Wert der Ruderlage. Max. Wertebereich 0 - 1023 (0V - 5V)
    const int fernbedienungpin = A2; // Fernbedienungspotentiometer liegt an Analogeingang A2 (Pin 21)
    int rudervorgabe = 0 ; // allgemeiner Vorgabewert für die Ruderlage
    int fernbedienung = 0; // Aktueller Vorgabewert der Fernbedienung
    const int ruderenablepin = 12; //Ruderenable liegt an Pin 12 (D8) Digitaloutput
    int ruderenable = LOW; // Ruderenable, Wertebereich LOW oder HIGH. LOW -> AUS, HIGH -> EIN
    const int inruderrepin = 10; //PWM-Eingang Ruder rechts (Pin 10/D6)
    int ruderre = 0; // Aktueller PWM-Wert für Ruder nach rechts.

    int16_t ax = 0; // Beschleunigung Querachse (Pitch)
    int16_t ay = 0; // Beschleunigung Längsachse (Roll)
    int16_t az = 0; // Beschleunigung Hochachse (Yaw)
    int16_t mx = 0; // Magnetvektor Längsachse
    int16_t my = 0; // Magnetvektor Querachse
    int16_t mz = 0; // Magnetvektor Hochachse
    int16_t tmp = 0; // Temperatur aus dem MPU
    int16_t gx = 0; // Drehbeschleunigung Längsachse
    int16_t gy = 0; // Drehbeschleunigung Querachse
    int16_t gz = 0; // Drehbeschleunigung Hochachse

    int iA = 0; // Zählervariable Für Beschleunigung
    int iM = 0; // Zählervariable für Magnetwert
    int i = 0; // Zählervariable
    long n = 0; // Speichervariable wird nur zum Finden der Korrekturwerte gebraucht.
    int16_t arrayax[11]; // Array zum Speichern von 10 Beschleunigungsrohwerten x für Glättung
    int16_t arrayay[11]; // Array zum Speichern von 10 Beschleunigungsrohwerten y für Glättung
    int16_t arrayaz[11]; // Array zum Speichern von 10 Beschleunigungsrohwerten z für Glättung
    int16_t kax = -500 ; // Korrekturwert für Nullpunkt, empirisch gefunden.
    int16_t kay = -103; // Korrekturwert für Nullpunkt, empirisch gefunden.
    int16_t kaz = 1570; // Korrekturwert fuer Nullpunkt, empirisch gefunden
    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
    int kurs = 0; // Aktueller Kurs in Grad (0-360)
    //************************************************** *******************
    void normierungshilfe()// hilft bei der Ermittlung der Nullpunktskorrektur, nur zum Debuggen
    { //Summiert den Rohwert, bildet den Durchschnitt und zeigt die Abweichung vom Nullpunkt,
    i=i+1; // Zeiger für den nächsten Durchlauf inkrementieren
    n = n+az;
    Serial.print(" AZ = "); Serial.print(az);
    Serial.print(" Zahlervariable = "); Serial.print(i);
    Serial.print(" Summe = "); Serial.print(n);
    Serial.print(" AZ Durchschnitt = "); Serial.println(n/i);
    if (i>1000)
    {
    i=0; // Array voll, Zeiger zurücksetzen
    n=0;
    }
    }
    //************************************************** *******************

    void init_I2C() //Subroutine zur Initialisierung des I2C-Busses
    {
    Wire.begin();
    Wire.beginTransmission(MPU);
    Wire.write(0x6B); // PWR_MGMT_1 register
    Wire.write(0); // set to zero (wakes up the MPU-6050)
    Wire.endTransmission(true); Wire.begin(); //Kompass
    Wire.beginTransmission(MAG); // Modus continous
    Wire.write(byte(0x02)); //Sendung für X MSB register Magnetometer
    Wire.write(byte(0x00));
    Wire.endTransmission(); // Ende der Sendung
    Serial.begin(9600); // Serial Monitor initialisieren
    }
    //************************************************** *******************
    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)
    }
    //************************************************** **********************
    void normiereBeschleunigungsrohwert()// die Rohwerte korrigieren (um die per
    // Normierungshilfe ermittelten
    // Korrekturwerte)
    {
    ax = ax + kax ; //Nullpunktskorrektur
    ax = ax / 50; // Endgröße korrigiert
    ay = ay + kay ; //Nullpunktskorrektur ay
    ay = ay / 50 ; // Endgröße ay
    az = az + kaz ; //Nullpunktskorrektur az
    az = az / 50 ;// Endgroße az
    }
    //************************************************** **********************
    void glaetteBeschleunigungsrohwert()
    { // 1.) Array beschreiben
    arrayax[iA] = ax; //Array entsprechend iA mit Beschleunigung x beschreiben
    arrayay[iA] = ay; //Array entsprechend iA mit Beschleunigung y beschreiben
    arrayaz[iA] = az; //Array entsprechend iA mit Beschleunigung z beschreiben
    iA=iA+1; // Zeiger für den nächsten Durchlauf inkrementieren

    if (iA>10)

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

    //2.) Array lesen
    ax=(arrayax[0]+arrayax[1]+arrayax[2]+arrayax[3]+arrayax[4]+arrayax[5]+arrayax[6]+arrayax[7]+arrayax[8]+arrayax[9]+arrayax[10])/10; //Durchschnitt aus 10 Werten
    ay=(arrayay[0]+arrayay[1]+arrayay[2]+arrayay[3]+arrayay[4]+arrayay[5]+arrayay[6]+arrayay[7]+arrayay[8]+arrayay[9]+arrayay[9])/10; //Durchschnitt aus 10 Werten
    az=(arrayaz[0]+arrayaz[1]+arrayaz[2]+arrayaz[3]+arrayaz[4]+arrayaz[5]+arrayaz[6]+arrayaz[7]+arrayaz[8]+arrayaz[9]+arrayaz[9])/10; //Durchschnitt aus 10 Werten
    //Nach dieser Routine sind die Kompassrohwerte ax, ay, az beruhigt

    }
    //************************************************** ***********************************
    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
    }
    //************************************************** ************************************




    Das ist eine alte Version. Versuche nicht, das in Betrieb zu nehmen! Ist nur ein Beispiel für das Vorgehen!
    Viel Spaß damit!
    nw

    PS: Ich mußte den größten Teil des Sourcefiles rauslöschen, das Forum hat es sonst nicht akzeptiert.
    Πάντα ῥεῖ (*)
    * Man kann nicht zweimal auf dem selben Fluß fahren.

  2. #322
    Registriert seit
    09.01.2016
    Beiträge
    1.404

    Standard

    Zitat Zitat von haribo Beitrag anzeigen
    -beschäftigung mit filtern oder PID läuft parallel
    -versuch eure ansätze nachzuvollziehen auch parallel
    Hallo,

    Filter:
    http://www-users.cs.york.ac.uk/fisher/mkfilter
    Du darfst nur Tiefpassfilter nutzen, nie Hochpässe (keine "D"-Anteile).

    Wir sprechen hier von erwünschten Grenz-Frequenzen zwischen 1/2 Hz (max. 1 Hz) bis ca. 1/20 Hz.
    Daraus folgt eine Compass-Abtastraten von min. 2 pro Sekunde (2 baud).
    Schneller geht immer, aber ebenso wird sich damit die erwünschte Grenzfrequenz erhöhen und deine Regelung wird unnötig zappelig.

    +++
    Summary
    You specified the following parameters:

    filtertype = Butterworth
    passtype = Lowpass
    ripple =
    order = 2
    samplerate = 2
    corner1 = 0.05
    corner2 =
    adzero =
    logmin =

    Results

    Command line: /www/usr/fisher/helpers/mkfilter -Bu -Lp -o 2 -a 2.5000000000e-02 0.0000000000e+00
    raw alpha1 = 0.0250000000
    raw alpha2 = 0.0250000000
    warped alpha1 = 0.0250515313
    warped alpha2 = 0.0250515313
    gain at dc : mag = 1.804169259e+02 phase = 0.0000000000 pi
    gain at centre: mag = 1.275740317e+02 phase = -0.5000000000 pi
    gain at hf : mag = 0.000000000e+00

    S-plane zeros:

    S-plane poles:
    -0.1113010212 + j 0.1113010212
    -0.1113010212 + j -0.1113010212

    Z-plane zeros:
    -1.0000000000 + j 0.0000000000 2 times

    Z-plane poles:
    0.8893158889 + j 0.0995986767
    0.8893158889 + j -0.0995986767

    Recurrence relation:
    y[n] = ( 1 * x[n- 2])
    + ( 2 * x[n- 1])
    + ( 1 * x[n- 0])

    + ( -0.8008026467 * y[n- 2])
    + ( 1.7786317778 * y[n- 1])

    Ansi ``C'' Code


    /* Digital filter designed by mkfilter/mkshape/gencode A.J. Fisher
    Command line: /www/usr/fisher/helpers/mkfilter -Bu -Lp -o 2 -a 2.5000000000e-02 0.0000000000e+00 -l */

    #define NZEROS 2
    #define NPOLES 2
    #define GAIN 1.804169259e+02

    static float xv[NZEROS+1], yv[NPOLES+1];

    static void filterloop()
    { for (;
    { xv[0] = xv[1]; xv[1] = xv[2];
    xv[2] = next input value / GAIN;
    yv[0] = yv[1]; yv[1] = yv[2];
    yv[2] = (xv[0] + xv[2]) + 2 * xv[1]
    + ( -0.8008026467 * yv[0]) + ( 1.7786317778 * yv[1]);
    next output value = yv[2];
    }
    }



    +++

    Anmerkung:
    Das obere Smiley ist in Wahrheit ein ";".


    Peter
    Geändert von K.Lauer (29.04.2020 um 15:14 Uhr)

  3. #323
    Registriert seit
    12.02.2009
    Beiträge
    2.649

    Standard

    ist [n-1] der gemessene vorhergehende messwert, oder der auch mittels der formel gefilterte vorherige messwert?

    versteh ich das ~~ richtig?
    die K.Lauer smile relation:
    y[n] = ( 1 * x[n- 2])
    + ( 2 * x[n- 1])
    + ( 1 * x[n- 0])
    + ( -0.8008026467 * y[n- 2])
    + ( 1.7786317778 * y[n- 1])

    würde bei sucher ungefähr so aussehen: yv[10] = 0.1 * yv[1] + 0.1 * yv[2] + ... + 0.1 * yv[10] ???

    also jeder möchte mit den jeweiligen berechnungen zu schnelle (zu unruhige) werte-änderungen der kompass eingabe beruhigen,
    danach den hiermit errechneten "output value" dann im sinne von PID als P-wert zur berechnung der gewünschten servo aktion benutzen



    @sucher: [nt16_t ax = 0; // Beschleunigung Querachse (Pitch)]
    in meinem kenntnisstand wäre bei nem flugzeug "pitch" die bewegung welche man mit dem höhenruder beinflussen kann, also eine DREHBEWEGUNG um die querachse,
    "Beschleunigung Querachse" wäre demgegenüber eine "rechts/links" versetzung, also in richtung der querachse wie es z.B. durch ne seitliche böe ausgelöst werden könnte

  4. #324
    Registriert seit
    09.01.2016
    Beiträge
    1.404

    Standard

    Hallo,

    ich benannte dir ein Butterworth-Verhalten.

    Vielleicht rechnest du selbst mit Excel nach, schau dir das Ergebnis der Impulsantwort an (Regelverhalten).
    Jede Excel-Spalte steht für einen anderen Index und
    der Index steht für fortlaufende Abtastwerte.
    Dann lässt du dir vom Excel eine Kurve der Ausgangswerte zeichen.

    Deckt sich übrigens mit den folgenden Schaltbildern so ziemlich 1:1.
    Einzig die Verstärkungselemente können etwas anders (d.h. für Rechner optimaler) verteilt sein
    https://de.wikipedia.org/wiki/Filter..._Impulsantwort
    https://de.wikipedia.org/wiki/Filter..._Impulsantwort


    Peter
    Geändert von K.Lauer (29.04.2020 um 18:14 Uhr)

  5. #325
    Registriert seit
    07.10.2012
    Ort
    Mittelfranken, weit vom Wasser
    Beiträge
    2.589

    Standard

    Hallo haribo, die Rotationsbeschleunigungen habe ich bisher bei keiner Version ausgewertet, obgleich das sehr sinnvoll aussieht, ich war bisher noch nicht so weit. In meinem Sourcefile ist ax die Linearbeschleunigung in der x-Achse, bei der vorgesehenen Montage des Sensors ist das eine Horizontalrichtung, steht senkrecht auf z bzw y . Diese Beschleunigungen braucht man, um die reale Senkrechte (= Erdbeschleunigung) krängungsunabhängig zu berechnen, die man wiederum braucht, um die horizontale Komponente der Magnetvektoren zu berechnen. Die Formeln dazu habe ich mir nicht ausgedacht, sondern ich habe bestimmt ein Dutzend Varianten (die sich alle ähnlich sind) durchprobiert. Dabei ist die Variable als Int16, also Signed 16-bit integer deklariert. Eine Deklaration als Fließkommazahl macht beim besten Willen keinen Sinn, obgleich es hier vorgeschlagen wurde, weil der Wert aus dem Sensor nicht anders gelesen wird. Als float wird nur eine Genaugikeit vorgetäuscht, die es tatsächlich nicht gibt.
    Ich habe auch zur Beruhigung der Werte diverse Kalman-Filter durchprobiert, keine Variante brachte den gewünschten Effekt. Die Durchschnittsbildung habe ich mir aus Verzweiflung tatsächlich selbst ausgedacht und programmiert. Ich habe festgestellt, daß der Wert mit 10 Sampeln stocksteif steht. Es hängt natürlich von der Durchlaufgeschwindigkeit des Programms und damit von dessen Größe ab, wie schnell das auf tatsächliche Änderungen reagiert. Ich habe es nicht gemessen, aber bei meinen diversen Programmversionen gibt das mindestens 100 Durchläufe/Sekunde, das bedeutet eine grundlegende Reaktion in 1/10 Sekunde. Bei der Trägheit des Schiffes wirklich zu vernachlässigen. Dieser Programmteil kann beliebig verlängert oder verkürzt werden, und ist so in allen meinen Programmvarianten enthalten.
    Viele Grüße
    nw
    Πάντα ῥεῖ (*)
    * Man kann nicht zweimal auf dem selben Fluß fahren.

  6. #326
    Registriert seit
    09.01.2016
    Beiträge
    1.404

    Standard

    Zitat Zitat von sucher Beitrag anzeigen
    Ich habe es nicht gemessen, aber bei meinen diversen Programmversionen gibt das mindestens 100 Durchläufe/Sekunde, das bedeutet eine grundlegende Reaktion in 1/10 Sekunde.
    Hallo,

    tatsächlich 1/9600s, Obere "Grenzfrequenz", wenn man es überhaupt so sagen darf, 9600/7 Hz, also so um 1300 Hz.

    Für dich käme dieses Butterworth-Filter in Frage, das "klingelt" auch weniger:

    #define NZEROS 2
    #define NPOLES 2
    #define GAIN 8.992292442e+00

    static float xv[NZEROS+1], yv[NPOLES+1];

    static void filterloop()
    { for (;
    { xv[0] = xv[1]; xv[1] = xv[2];
    xv[2] = next input value / GAIN;
    yv[0] = yv[1]; yv[1] = yv[2];
    yv[2] = (xv[0] + xv[2]) + 2 * xv[1]
    + ( -0.3057975229 * yv[0]) + ( 0.8609721320 * yv[1]);
    next output value = yv[2];
    }
    }

    Der Vorteil ist, das Antwortverhalten ist bei diesem Code fast beliebig einstellbar.


    Peter
    Geändert von K.Lauer (30.04.2020 um 06:33 Uhr)

  7. #327
    Registriert seit
    12.02.2009
    Beiträge
    2.649

    Standard

    sucher, dass die x-achse senkrecht auf z bzw y steht, ist so eine grundlage die sogar ich axiom nennen würde

    aber ich bekomme bisher nicht heraus in welcher richtung bezogen auf dein schiff diese achsen bei dir liegen,

    ich kann es nicht herausbekommen weil ich deine erklärung :"int16_t ax = 0// "Beschleunigung Querachse (Pitch)" für insich wiedersprüchlich halte, wiedersprüchlich weil "pitch" eine objekt- (hier schiffs-)bewegung ist die nicht zu beschleunigung querachse passt, und ich halte "pitch" für definiert...

    evtl könnte ich es etwas besser verstehen wenn ich erstmal begreifen würde in welchen richtungen du die xyz-achsen definierst

    also folgender möglichst eindeutig formulierter frageversuch:
    -welche achse liegt bei deinem projekt im schiff parallel zum mast?
    -welche parallel zur bug-heck linie liegt
    haribo
    -welche parallel zur bb-stb linie liegt

  8. #328
    Registriert seit
    07.10.2012
    Ort
    Mittelfranken, weit vom Wasser
    Beiträge
    2.589

    Standard

    Hallo haribo, das ist tatsächlich unerheblich, denn diese Kalkulation dient nur zur Ermittlung der tatsächlichen krängungs- und Stampf-unabhängigen Normalkraft, also des senkrechten Vektors der Erdbeschleunigung. Anderes wird damit nicht gemacht. Den lotrechten Vektor braucht man, um die horizontale Komponente der 3Magnetvektoren zu berechnen, denn das ist der tatsächliche Kompaßkurs.
    Das ist so ähnlich wie die kardanische Aufhängung Deines Hauptkompasses, da ist es auch gleichgültig, welche von dessen Achsen ausgelenkt wird.
    Auch wenn die Stampfbewegung eine weit geringeren Einfluß hat als die Rollbewegung, in den Formeln werden beide gleichberechtigt behandelt.
    Eventuell ist eine Vereinfachung denkbar, wenn man die Stampfbewegung einfach ignoriert, etwa wie beim Kochherd, der auch nur mit einer Achse aufgehängt ist, das Programm könnte dadurch etwas schneller werden. Aber solange kein Tempoproblem erkennbar ist, würde ich es dabei belassen.

    Ich warne Dich, Du vergeudest Lebenszeit, wenn Du versuchst, diese Kalkulationen zu durchleuchten, ohne den Sensor dazu zu haben! Eigentlich sind dieses Berechnungen, auch wenn sie im 3D Raum stattfinden, verhältnismäßig einfach (für den einen mehr, für den anderen weniger) zu durchschauen, aber die Übersetzung in ein C-Programm hat so seine Tücken. Da haben sich schon schlauere Geister damit befaßt, und ihre Ergebnisse Open source gestellt. Da kannst Du Dich nach Belieben bedienen.
    Schau Dir mal dieses an: https://create.arduino.cc/projecthub...tometer-df9dc1
    Von dieser Sorte gibt es dutzende Beispiele. Das vordergründige Problem ist, daß die Adressen des Sensors in diesem Beispiel garantiert nicht die gleichen sind, wie bei Deinem Sensor. Das Beispiel wird daher zunächst nicht laufen. Das zweite Problem ist, daß tausende von Verschiedenen Include-Files im Netz herumschwirren, und Du zunächst garantiert das falsche erwischst, was Dich zur Verzweiflung bringen wird, weil erstmal garnichts geht, und Du keinen Fehler finden kannst.
    Du wirst sehen, die wahren Probleme liegen ganz woanders als erwartet, und etwa Diskussionen um Butterworth-Filter oder Abtastfrequenzen gehen an der Sache meilenweit vorbei!
    Viele Grüße
    nw
    Πάντα ῥεῖ (*)
    * Man kann nicht zweimal auf dem selben Fluß fahren.

  9. #329
    Registriert seit
    12.02.2009
    Beiträge
    2.649

    Standard

    ok sucher, dann verschwende ich keine weitere zeit mehr dein program zu versuchen besser zu verstehen, wenn du selbst meinen versuch die angesetzte achslage überhaupt nachzuvollziehen, als solches deklarierst...

    nen filter mit definiert einstellbarer grenze zu verwenden und die grenze z.B. dann nicht herumzustochern sondern rechnerisch so zu setzen dass sie yaw-bewegungen hervorgerufen aus den erwarteten wellen wegfiltert aber böen erkennt, det leuchtet mir sowas von ein

    also auch nochmal nachgefragt an KL : sind x[index] die messwerte, und die regelantwort des filters dann y[index] ? und [index] zählt hoch? hm da fehlt offenbar noch irgendwie das GAIN... scheints gilt: messwerte[index]/GAIN=x[index]



    haribo
    Geändert von haribo (30.04.2020 um 13:18 Uhr)

  10. #330
    Registriert seit
    07.10.2012
    Ort
    Mittelfranken, weit vom Wasser
    Beiträge
    2.589

    Standard

    Hallo haribo, was Du da siehst sind drei gänzlich unterschiedliche Programmteile: Lesen, Glätten und berechnen, in dieser Reihenfolge. (es könnte sein, daß der Zusammenhang der Löschaktion zum Opfer gefallen ist, denn das Yachtforum akzeptiert maximal 10000 Zeichen). Soweit ich mich erinnere, zappelt der ungeglättete Kompaßwert um 30° hin und her, total unbrauchbar. Also nach dem Lesen erstmal glätten. Erst dann mit den geglätteten Werten rechnen.
    Zur Verdeutlichung:
    void loop()
    {

    read_mpu();
    //Serial.print(" | AYroh = "); Serial.print(ay);
    //Serial.print(" | AYroh = "); Serial.print(ay);
    //normierungshilfe();

    glaetteBeschleunigungsrohwert();
    normiereBeschleunigungsrohwert();
    //Serial.print(" AX normiert/geglaettet = "); Serial.println(ax);
    //Serial.print(" AY normiert/geglaettet = "); Serial.print(ay);
    //Serial.print(" AZ normiert/geglaettet = "); Serial.println(az);
    read_mag();
    //glaetteMagnetrohwert();
    //normiereMagnetrohwert();
    Serial.print(" MX Rohwert = "); Serial.print(mx);
    Serial.print(" MY Rohwert = "); Serial.print(my);
    Serial.print(" MZ Rohwert = "); Serial.print(mz);
    berechnekurs();
    Serial.print(" Kurs = "); Serial.println (kurs);
    //Serial.print(" Rudervorgabe = "); Serial.print(rudervorgabe);
    leseruderlage();
    //Serial.print(" Ruderlage = "); Serial.println(ruderlage);
    //Serial.print(" | AZ = "); Serial.print(az);
    //Serial.print(" | Tmp = "); Serial.print(tmp/340.00+36.53); //equation for temperature in degrees C from datasheet
    //Serial.print(" | GX = "); Serial.print(gx);
    //Serial.print(" | GY = "); Serial.print(gy);
    //Serial.print(" | GZ = "); Serial.println(gz);
    delay(100);
    }
    Was Du hier sieht ist der Loop-Teil einer vorläufigen Programmversion, das tatsächliche im AP befindliche Programm liegt auf einem Laptop am Schiff, und das ist momentan in GR, und da kann ich bekannterweise grad nicht ran! Du Siehst auch, daß ich da fürs Debuggen eine ganze Menge von Werten im serial Monitor ausdrucken lasse, die ich wenn nicht gebraucht mit // in Komm
    entare verwandelt werden, damit es nicht assembliert wird.
    Die Subroutine, die Dich momentan so heftig interessiert ist diese:
    //************************************************** **************************************
    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;
    }



    //************************************************** **************************************

    Das habe ich irgendwo rauskopiert und bei mir zum laufen gebracht. Das Beispiel aus meinem vorigen Post schaut ganz genauso aus. Ich habe da einige durchprobiert, sie sind bis auf Details identisch. Es ist jedoch viel Arbeit, die Namen der Variablen anzupassen, weil sie in jedem Beispiel anders benannt sind.
    Viele Grüße
    nw
    Πάντα ῥεῖ (*)
    * Man kann nicht zweimal auf dem selben Fluß fahren.

Ä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
  •