die Woche lief leider so überhaupt nicht wie geplant. Ich hatte leider nicht wirklich viel Zeit für das Projekt, deswegen melde ich mich erst heute wieder.
Die Werte der open Loop fahrt habe ich aufgezeichnet, die Position in Schritten des Encoders und die die Zeit in Mikrosekunden
Jetzt habe ich leider den Code dazu nicht mit hier her genommen. Auf jeden Fall habe ich pwm.duty auf 100 gesetzt und dann in einer Schleife die Position des Encoders und die Zeit in Mikrosekunden aufgenommen und das ganze im 0,01 Sekunden Takt. Also wie der Soll-Ist-Vergleich auch.
Nun habe ich mal die Beschleunigung ausgerechnet und die zwei Werte "T" und "L". Bin aber gerade erst fertig geworden und konnte es noch nicht testen.
Aber mein Gefühl sagt mir dass die Werte so nicht hinhauen, ich zeig euch trotzdem mal was ich gerechnet habe. Die Konstanten sind die verlinkten Werte als Listen.
Von der Programmierung her geht das ein oder andere sicherlich noch eleganter, aber darauf habe ich gerade keinen Wert gelegt, weil ich mich erst mal auf die Rechnungen konzentrieren wollte. Die Beschleunigung habe ich nur interessehalber berechnet.
Mal noch etwas zu meinen Gedanken dabei. Mit den Positionen und den dazugehörigen Zeitabschnitten kann ich den Weg wieder grafisch darstellen. Die Zeit in der beschleunig wird, wird parabellförmig aussehen und bei voller Drehzahl wird eine Gerade mit konstanter Steigung entstehen (wohl gemerkt, in einer Welt ohne Reibung etc.). Da ich keine mathematische Funktion habe, die den Weg darstellt, musste ich mir was anderes überlegen um den Wendepunkt und damit den Anfang der Gerade zu bestimmen. Also dachte ich mir, ich berechne für jede Position die Steigung und vergleiche sie mit der nächsten und wenn beide gleich sind, dann habe ich den Anfang meiner Geraden gefunden. Naja das hat dann erst funktioniert, nachdem ich das Runden auf 5 Stellen in den Vergleich einbezogen habe.
Für meine Werte "T" und "L" muss ich die Gerade verlängern, bis sie die x-Achse schneidet (das tut sie bei y=0) und einmal benötige ich den Wert der x-Achse wenn die Gerade die Endposition schneidet (y=Endposition). Da mir die Werte komisch vorkommen, habe ich das mir mal grafisch ausgeben lassen und man sieht, dass es keine konstante Steigung gibt, was zu erwarten war und man auch in früheren Aufzeichnungen schon gesehen hat.
Naja jetzt hier mal der Code:
Code: Alles auswählen
from matplotlib import pyplot as plt
def draw_graphics(straight_line):
plt.plot(TIME_STAMP, POSITIONS, color='r')
plt.plot(TIME_STAMP, straight_line, color='g')
plt.xlabel("Zeit")
plt.ylabel("Step")
plt.show()
def calculate_pitch():
pitches = [(POSITIONS[index + 1] - position) / (TIME_STAMP[index + 1] - TIME_STAMP[index]) for index, position in
enumerate(POSITIONS) if index + 1 < len(POSITIONS)]
for index in range(len(pitches)):
if index + 1 < len(pitches):
if round(pitches[index], 5) == round(pitches[index + 1], 5):
if not index == 0:
return pitches[index], index
def calculate_acceleration(end_acceleration):
# 10**6 -> microsecond in second
return 2 * POSITIONS[end_acceleration] / (TIME_STAMP[end_acceleration] * 10**-6)**2
def calculate_y_axis_section(end_acceleration, pitch):
# equation of a straight line: y(x) = pitch * x + y_axis_section
return POSITIONS[end_acceleration] - (pitch * TIME_STAMP[end_acceleration])
def calculate_constants(pitch, y_axis_section):
# equation of a straight line: y(x) = pitch * x + y_axis_section
# y(x) = 0
delay_time = -y_axis_section / pitch
# y(x) = Endposition
constant_time = (POSITIONS[-1] - y_axis_section) / pitch
return delay_time, constant_time
def calculate_straight_line(pitch, y_axis_section, end_acceleration):
return [(pitch * x) + y_axis_section if x > TIME_STAMP[end_acceleration] else None for x in TIME_STAMP]
def main():
pitch, end_acceleration = calculate_pitch()
print(f'Pitch: {pitch}')
print(f'Acceleration: {calculate_acceleration(end_acceleration):0.2f} 1/s²')
y_axis_section = calculate_y_axis_section(end_acceleration, pitch)
delay_time, constant_time = calculate_constants(pitch, y_axis_section)
print(f'L: {delay_time}')
print(f'T: {constant_time}')
straight_line = calculate_straight_line(pitch, y_axis_section, end_acceleration)
draw_graphics(straight_line)
if __name__ == '__main__':
main()
Grüße
Dennis
