quadrocopter

[ju.ha.sch]

HALLO MIR GEFÄÄLT DEIN PROJEKT ECHT GUT: wenn ich die technische quallitäten hätte würde ichs auch nachbauen
ein tipp: ich würde einen ausleger mit signalfarbe ansprühen - zur orientierung
würdest du mir sagen welche maße die carbon-platten haben - die site vom vertreiber ist ziemlich unübersichtlich- finde ich

[goara]

@willa... nee das is schon auch der rahmen,, sind zwar nur 2 schichten gewebe, aber das is stabil genug um da alles dranzubauen...
@juhasch welche carbonplattten meinst du denn ??

[ABSIMON]

Hallo zusammen,

ich kann mich auch nur anschließen, tolles Projekt. Mich interessiert insb.
die Flugsteuerung, zur Simulation habe ich das ganze mal "nachgebaut",
hier findet man Beispielwerte in den [eckigen Klammern].

[php:1:b23af47a9c]Schleife

Schritt 1. "Get Analog"

// Differenz zum Ausgangswert errechnen
Gyro_nick [-14] = Getadc(7) [637] - Gyro_nick_init [646 - Mittel aus 100 Messungen]
Gyro_roll [-11] = Getadc(4) [594] - Gyro_roll_init [594 - Mittel aus 100 Messungen]
Gyro_yaw [20] = Getadc(5) [621] - Gyro_yaw_init [603 - Mittel aus 100 Messungen]
Besch_x [7] = Getadc(2) [376] - Besch_x_init [357 - Mittel aus 100 Messungen]
Besch_y [13] = Getadc(1) [355] - Besch_y_init [354 - Mittel aus 100 Messungen]
Besch_z [-17] = Getadc(3) [363] - Besch_z_init [~356 - Mittel aus Besch_x_init & Besch_y_init]

// Differenz zum Motorwerte hinzuaddieren
Gyro_nick_m [-9] += Gyro_nick [-14]
Gyro_roll_m [-24] += Gyro_roll [-11]
Gyro_yaw_m [44] += Gyro_yaw [20]

// Differenz zum Motorwerte hinzuaddieren
Besch_x_m [94] += Besch_x [101]
Besch_y_m [59] += Besch_y [13]
Besch_z_m [-45] += Besch_z [-17]

Schritt 2. "Fernsteuerung"

// Differenz zum Ausgangswert errechnen
Kanal_nick [19] = Puls(3) [276] - Kanal_nick_init [276]
Kanal_roll [3] = Puls(2) [332] - Kanal_roll_init [319]
Kanal_yaw [-8] = Puls(4) [511] - Kanal_yaw_init [496]
Kanal_pitch [9] = Puls(5) [768] - Kanal_pitch_init [783]

Schritt 3. "Mixer"

// Die Motor_soll Werte neu berechnen

// Pitch (plus 40?) vorab auf alle Motoren verteilen
Motor_soll_v [49] = Kanal_pitch [9] + 40
Motor_soll_r [49] = Kanal_pitch [9] + 40
Motor_soll_h [49] = Kanal_pitch [9] + 40
Motor_soll_l [49] = Kanal_pitch [9] + 40

// ggf. Maximalwerte abfangen (Motor_soll_v [24] > Motorbegrenzung [130] ...)

// Nicken.

// 1. Funke - Steuersignal Nick auf Motor vorne(- ab) und hinten (+ auf) verteilen
Motor_soll_v [30] -= Kanal_nick [19]
Motor_soll_h [68] += Kanal_nick [19]

// 2. Gyro - Gyro Differenz ebenfalls auf das Motor-Steuersignal verteilen
Motor_soll_v [21] += Gyro_nick_m [-9]
Motor_soll_h [77] -= Gyro_nick_m [-9]

// 3. Acc - Beschleunigungs Differenz letztlich auf das Motor-Steuer-Gyro Signal verteilen
Motor_soll_v [122] += Besch_x_m [101]
Motor_soll_h [-24] -= Besch_x_m [101]

// Rollen.

// roll
Motor_soll_r [46] -= Kanal_roll [3]
Motor_soll_l [52] += Kanal_roll [3]
// gyro roll
Motor_soll_r [70] -= Gyro_roll_m [-24]
Motor_soll_l [28] += Gyro_roll_m [-24]
// acc roll
Motor_soll_r [129] += Besch_y_m [59]
Motor_soll_l [-31] -= Besch_y_m [59]

// Vertikal drehen

// yaw
Motor_soll_v [130] -= Kanal_yaw [-8]
Motor_soll_l [-39] += Kanal_yaw [-8]
Motor_soll_r [93] += Kanal_yaw [-8]
Motor_soll_h [137] -= Kanal_yaw [-8]

// ggf. Minimalwerte abfangen Motor_soll_v [24] < 1 ...

Schritt 4. "Daten an die Motoren senden" [/php:1:b23af47a9c]

Ich hoffe das ist soweit exemplarisch korrekt.
Das eigentliche Stück Software ist ja das aufaddieren von
Funke / Gyro / ACC. Letztlich muß man vorab nur sicher
gehen, das die Signale richtig skaliert vorliegen.
(wenn ich es richtig verstanden hab...)

Wollte ich nur kurz posten, vielleicht für einige interessant.
Sobald ich etwas zum Kalmanfilter finde, poste ich das hier gleich,
sooo kompliziert kann es nicht sein....

Viele Grüße
ABSIMon

[goara]

@ ABSIMON

ja das ist so korrekt..
Die 40 wird addiet, damit man wenn man den Gasknüppel ganz unten hat gleich eine gewisse Anfangsgeschwindigkeit hat, ansosnten gibt man Vollgas und hebt noch nicht ab, Ne stärker verstärung könnte das zwar auch beheben, aber dann wär es nich mehr so feinfühlig.
So wie die acc Signal bis jetz addiert werden bringt das aber nicht so viel.
Sinnvoller ist es die zum trimmen des Gyrointegrals zu verwenden, da bin ich momentan dran.

[ABSIMON]

Hallo goara,

bzgl. Kalmanfilter - hier habe ich die Homepage www.ulrichradig.de gefunden mit einem kleinen Projekt - alle anderen Projekte sind sehr aufwendig, Code Interpretation = mehrere Tage.

Hier habe ich versucht das Script fc.c mit PHP zu simulieren um das Vorgehen zu verstehen. Mit Testwerten.

[php:1:bba2501f77]
<?php

// Werte initalisieren
$y_old = 0;
$y_sum = 0;
$y_e_sum = 0;
$y_rc_mittelwert = 0;

$x_old = 0;
$x_sum = 0;
$x_e_sum = 0;
$x_rc_mittelwert = 0;

$gier_old = 0;

// Neutralwert errechen (Normalerweise 100 Durchläufe, hier nur 10)
function adc_neutral($a, $b) {
$wert = 0;
$i = 10;
while($i--) {
$wert += rand($a, $b);
}
return (int)$wert / 10;
}
// Nochmal das gleiche für einen aktuellen Wert... (etwas doppelt gemoppelt)
function get_adc($neutral, $a, $b) {
$wert = 0;
$i = 10;
while($i--) {
$wert += $neutral - rand($a, $b);
}
return array((int)$wert, 10);
}

$y_rc_mittelwert = adc_neutral(100, 250);

// Drei Testdurchläufe
$i = 3;
while ($i--) {

// Initalisieren neuer Werte
list($adc0_value_mux["ADC_GIER"], $adc_count["ADC_GIER"]) = get_adc(adc_neutral(507, 567), 507, 567);
list($adc0_value_mux["ADC_ACCY"], $adc_count["ADC_ACCY"]) = get_adc(adc_neutral(420, 480), 420, 480);
list($adc0_value_mux["ADC_ACCX"], $adc_count["ADC_ACCX"]) = get_adc(adc_neutral(220, 280), 220, 280);
list($adc0_value_mux["ADC_NICK"], $adc_count["ADC_NICK"]) = get_adc(adc_neutral(276, 326), 276, 326);
list($adc0_value_mux["ADC_ROLL"], $adc_count["ADC_ROLL"]) = get_adc(adc_neutral(376, 416), 376, 416);

$rc_ch["RC_NICK"] = adc_neutral(100, 250);
$rc_ch["RC_GAS"] = adc_neutral(100, 250);
$rc_ch["RC_GIER"] = adc_neutral(100, 250);

// ----------- Ab hier Starte die Code Interpretation fc.c - Copyright UlrichRadig.de !!! -------------


$gier = -($adc0_value_mux["ADC_GIER"] / $adc_count["ADC_GIER"]);

$y_out = 0;
$y_gyro_error = 0;
$y_b = $adc0_value_mux["ADC_ACCY"] / $adc_count["ADC_ACCY"];
$y_g = $adc0_value_mux["ADC_NICK"] / $adc_count["ADC_NICK"];

$x_out = 0;
$x_gyro_error = 0;
$x_b = $adc0_value_mux["ADC_ACCX"] / $adc_count["ADC_ACCX"];
$x_g = $adc0_value_mux["ADC_ROLL"] / $adc_count["ADC_ROLL"];

$e = $w = $rc_error = 0;
$motor_value = 10;

$tmp;

$adc_count["ADC_NICK"] = 0;
$adc_count["ADC_ACCY"] = 0;
$adc_count["ADC_ACCX"] = 0;
$adc_count["ADC_ROLL"] = 0;
$adc_count["ADC_GIER"] = 0;

$adc0_value_mux["ADC_NICK"] = 0;
$adc0_value_mux["ADC_ACCY"] = 0;
$adc0_value_mux["ADC_ACCX"] = 0;
$adc0_value_mux["ADC_ROLL"] = 0;
$adc0_value_mux["ADC_GIER"] = 0;

//---------------------------------------------------------------------------
print('$gier = '. $gier . ', $y_b = ' . $y_b . ', $y_g = ' . $y_g .
', $x_b = ' . $x_b . ', $x_g = ' . $x_g . '
');
//---------------------------------------------------------------------------
//PD Gyro (GIER)

//e = w - x (Sollwert = 0)
$e = ($gier * 0.5) - ($rc_ch["RC_GIER"] * 0.4);

//---------------------------------------------------------------------------
print(' $e = ' . $e );
//---------------------------------------------------------------------------

//P-Regelpart Kp * e
$gier = 4 * $e;

//---------------------------------------------------------------------------
print(' $gier = ' . $gier );
//---------------------------------------------------------------------------

//D-Regelpart Kd/ta * e (Zeit ta = 0,01s)
$gier += 10 * ($e - $gier_old);

//---------------------------------------------------------------------------
print(' $gier = ' . $gier . "
");
//---------------------------------------------------------------------------

$gier_old = $e;


//---------------------------------------------------------------------------
//Gyro Signal integrieren und an AAC abgleichen
$rc_error = $rc_ch["RC_NICK"] - $y_rc_mittelwert;

if (abs($rc_error) > 20) {
if ($rc_ch["RC_NICK"] > $y_rc_mittelwert) $y_rc_mittelwert += 3;
if ($rc_ch["RC_NICK"] < $y_rc_mittelwert) $y_rc_mittelwert -= 3;
} else {
if ($rc_ch["RC_NICK"] > $y_rc_mittelwert) $y_rc_mittelwert++;
if ($rc_ch["RC_NICK"] < $y_rc_mittelwert) $y_rc_mittelwert--;
}

//---------------------------------------------------------------------------
print(' $y_rc_mittelwert = ' . $y_rc_mittelwert);
//---------------------------------------------------------------------------

$y_sum += $y_g;

//---------------------------------------------------------------------------
print(' $y_sum = ' . $y_sum);
//---------------------------------------------------------------------------

$y_gyro_error = $y_sum - ($y_b * 70);

//---------------------------------------------------------------------------
print(' $y_gyro_error = ' . $y_gyro_error );
//---------------------------------------------------------------------------

if($y_gyro_error > 3000) $y_gyro_error = 3000;
if($y_gyro_error < -3000) $y_gyro_error =-3000;

$y_sum -= $y_gyro_error * 0.005;

//---------------------------------------------------------------------------
print(' $y_sum = ' . $y_sum . "
");
//---------------------------------------------------------------------------


//----------------------------------------
//PI - Regler

//e = w - x (Sollwert = 0)
$w = ($y_g * 0.3) + ($y_sum * 0.003);

//---------------------------------------------------------------------------
print(' $w = ' . $w);
//---------------------------------------------------------------------------

$e = $w - ($y_rc_mittelwert * 0.2);

//---------------------------------------------------------------------------
print(' $e = ' . $e);
//---------------------------------------------------------------------------

//Integral bilden und begrenzen (I-Anteil)
$y_e_sum += $e;
if ($y_e_sum > 3000) $y_e_sum = 3000;
if ($y_e_sum < -3000) $y_e_sum = -3000;

//---------------------------------------------------------------------------
print(' $y_e_sum = ' . $y_e_sum);
//---------------------------------------------------------------------------

//P-Regler Kp * e + Ki + e_sum_nick1 (P + I-Anteil)
$y_out = 3 * $e + ($y_e_sum * 0.025);

//---------------------------------------------------------------------------
print(' $y_out = ' . $y_out . "<hr>");
//---------------------------------------------------------------------------


//D-Regelpart Kd/ta * e (Zeit ta = 0,01s) (+D Anteil)
//$y_out += 2 * ($e - $y_old);
$y_old = $e;


//----------------------------------------
//Werte mischen

$motor_value = $rc_ch["RC_GAS"] + 70 + $y_out + $gier;
if ($motor_value < 5) $motor_value = 5;
if ($motor_value > 255) $motor_value = 255;
$PWM_Motor[0]= $motor_value;

$motor_value = $rc_ch["RC_GAS"] + 70 - $y_out + $gier;
if ($motor_value < 5) $motor_value = 5;
if ($motor_value > 255) $motor_value = 255;
$PWM_Motor[1]= $motor_value;

//---------------------------------------------------------------------------
print('$rc_ch["RC_GAS"] + 70 = ' . ($rc_ch["RC_GAS"] + 70) .
' $y_out = ' . $y_out .
' $gier = ' . $gier . "
");
print(' $PWM_Motor[1] = ' . $PWM_Motor[1] . ' $PWM_Motor[0] = ' . $PWM_Motor[0] . "<hr>");
//---------------------------------------------------------------------------


}

[/php:1:bba2501f77]

Das Debug Ergebnis sieht dann so aus.

[php:1:bba2501f77]

....


// Zweiter Durchlauf

$gier = 0.9, $y_b = 7.6, $y_g = 4.8, $x_b = 6.8, $x_g = 1.1
$e = -73.83 $gier = -295.32 $gier = -320.92
$y_rc_mittelwert = 192 $y_sum = -0.931 $y_gyro_error = -532.931 $y_sum = 1.733655
$w = 1.445200965 $e = -36.954799035 $y_e_sum = -77.911992035 $y_out = -112.812196906

$rc_ch["RC_GAS"] + 70 = 249.9 $y_out = -112.812196906 $gier = -320.92
$PWM_Motor[1] = 41.7921969059 $PWM_Motor[0] = 5

// Dritter Durchlauf

$gier = 5, $y_b = 2.4, $y_g = 10.9, $x_b = -6.3, $x_g = -5.9
$e = -69.3, $gier = -277.2, $gier = -231.9
$y_rc_mittelwert = 189, $y_sum = 12.633655 $y_gyro_error = -155.366345 $y_sum = 13.410486725
$w = 3.31023146017 $e = -34.4897685398 $y_e_sum = -112.401760575 $y_out = -106.279349634

$rc_ch["RC_GAS"] + 70 = 230.2 $y_out = -106.279349634 $gier = -231.9
$PWM_Motor[1] = 104.579349634 $PWM_Motor[0] = 5
[/php:1:bba2501f77]

Das Vorgehen kapier ich leider nicht... Mir erschließt sich hier keinerlei Logik... Bis jetzt. Naja, ich bleib dran...

Soweit Viele Grüße aus Neuss
ABSimon

[ABSIMON]

Hallo goara,

bzgl. Kalmanfilter
http://forum.mikrokopter.de/topic-5875.html

bzgl. PID Regler
http://forum.mikrokopter.de/topic-5864.html

Vielleicht hilft es ja weiter

Viele Grüße
ABSimon

[goara]

@ ABSIMON

Danke feur die Links...

Ich werde nacher mal versuchen den Kalman in Bascom zu schreiben. (das ist die erste Erklärung die ich sehe bei der ich nicht nur Bahnhof denke
Wenn ichs fertig hab stell ichs heir mal rein, dann könnt ihr mal sagen ob das so richtig wäre..

zu dem PID, wie der PID geht ist klar. das Problem was ich dabei habe ist, dass ich kein sauberes Gyrosignal habe (Rauschen / Drift) und mir der I-Anteil desswegen immer wegläuft und den Kopter an die Wand donnert.
Wobei man das über den Kalman ja beheben sollen könnte.

[ABSIMON]

Hi,

Das gleiche Problem hatte ich auch schon,
und hier hatte ich Dich auch schon zitiert

http://forum.mikrokopter.de/topic-5337-1.html

Hoffe das ist in Ordnung

Ich dachte bisher das liegt an meinen Testaufbau
(Lange angelötete Kabel, Komplexes und verrauschtes Testboard,
keinen externen ADC) ...

Sonst haben wir beide was übersehen, bei anderen klappt's ja auch
oder die Gyros sind defekt. (?)

Auf der anderen Seite, der mikrokopter unter mikrokopter.de arbeitet
laut einem User "nur" mit einem PD Regler, als ohne I Anteil ....
siehe http://forum.mikrokopter.de/topic-po...html#post76221
Obwohl der Quellcode vom mikrokopter super komplex ist (>
1000 Zeilen nur Flugsteuerung), da kann man sich auch irren...

Einen neuen Aufbau habe ich Ende des Monats, erst dann
kann ich auch selber mal experimentieren.

Bin dann mal gespannt.

Soweit, Viele Grüße

[ABSIMON]

bzgl.

das Problem was ich dabei habe ist, dass ich kein sauberes Gyrosignal habe (Rauschen / Drift) und mir der I-Anteil desswegen immer wegläuft

habe ich noch das hier gefunden

http://forum.mikrokopter.de/topic-5748.html

Habe das bei mir in nem Source mal so gemacht, dass ich
Werte unter einer gewissen Grenze (im Driftbereich)
berücksichtigt habe und sie jenachdem, ob zu hoch
oder zu niedrig, zu einer Variablen dazu bzw.
weggezählt habe. Wenn die Variable dann einen
gewissen Wert überschritten hat hab ich die
Mitte um einen Klick nach unten bzw. nach
oben korrigiert.

Vielleicht eine Hilfe

Viele Grüße

[goara]

@ AbSIMON.

so hatte ich mir das auch shcon überlegt, das Problem bei dieser Methode ist, das du zwangsläufig immer eine Hysterese bekommst. Dann läuft dir das signal zwar nciht mehr weg, dafür hinkt es aber stark hinterher, was es für die Regelung auch wieder unbrauchbar macht.

Grüsse