Das deutsche Python-Forum

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()

Code: Alles auswählen

def calculate_velocity():
    return [(POSITIONS[index + 1] - position) / (TIME_STAMP[index + 1] - TIME_STAMP[index]) for index, position in
               enumerate(POSITIONS) if index + 1 < len(POSITIONS)]

Code: Alles auswählen

from machine import Pin, ADC
from esp32 import MCPWM, PCNT
from time import sleep, ticks_us, ticks_diff
from LargeCounter import LargeCounter
from PathPlanner import PathPlanner
from PID import PID

try:
    import usocket as socket
except:
    import socket
import json

PWM_PINS = [[16, 17], [5, 23]]
ENCODER_PINS = [15, 2]
KP = 0.03
KI = 0
KD = 0


class WeldingControl:
    def __init__(self):
        encoder = PCNT(0, Pin(ENCODER_PINS[1]), Pin(ENCODER_PINS[0]))
        encoder.filter(100)
        self.count_angle = LargeCounter(encoder)
        self.welding_axis = MCPWM(0)
        self.welding_axis.bind(Pin(PWM_PINS[0][0]), Pin(PWM_PINS[0][1]))
        self.welding_axis.duty(0)
        self.path = PathPlanner(45, 180, 45, 0.1)
        self.pid = PID(KP, KI, -KD)
        self.actually_pos = []
        self.should_pos = []
        self.time_stamp = []
        self.record_motor_conduct()
        # self.open_loop()

    def open_loop(self):
        start = ticks_us()
        while True:
            sleep(0.01)
            time_ = ticks_diff(ticks_us(), start)
            actually_position = self.count_angle.counter()
            self.welding_axis.duty(100)
            if actually_position >= 500:
                self.welding_axis.duty(0)
                break
            self.actually_pos.append(actually_position)
            self.time_stamp.append(time_)

    def record_motor_conduct(self):
        start = ticks_us()
        while True:
            sleep(0.01)
            time_ = ticks_diff(ticks_us(), start)
            should_be_position = self.path(time_ / 1000)
            actually_position = self.translate_into_angle(self.count_angle.counter())
            new_pwm = self.pid(should_be_position - actually_position, time_)
            self.welding_axis.duty(new_pwm)
            if actually_position >= 270:
                self.welding_axis.duty(0)
                break
            self.should_pos.append(int(should_be_position))
            self.actually_pos.append(actually_position)
            self.time_stamp.append(time_)

    def translate_into_angle(self, value):
        return 360 * value // 1000


def listen_and_connect(pid_values):
    while True:
        cl, addr = s.accept()
        print("client connected from", addr)
        cl_file = cl.makefile("rwb", 0)
        while True:
            line = cl_file.readline()
            if not line or line == b"\r\n":
                break
        response = pid_values
        cl.send("HTTP/1.0 200 OK\r\nContent-type: text/html\r\n\r\n")
        cl.send(response)
        cl.close()


def make_json(welding_control):
    pid_values = [
        welding_control.time_stamp,
        welding_control.should_pos,
        welding_control.actually_pos,
    ]
    return json.dumps(pid_values)


def main():
    welding_control = WeldingControl()
    pid_values = make_json(welding_control)
    listen_and_connect(pid_values)


if __name__ == "__main__":
    main()

Code: Alles auswählen

#!/usr/bin/env python3
import requests
import matplotlib.pyplot as plt


def draw_graphics(time_stamp, should_be_position, actually_position):
    plt.plot(time_stamp, actually_position, color="r", label="Ist-Wert")
    plt.plot(time_stamp, should_be_position, color='g', label='Soll-Wert')
    plt.xlabel("Zeit")
    plt.ylabel("Winkel")
    plt.title("Soll-Ist-Vergleich")
    plt.legend()
    plt.show()


def translate_into_list(content):
    return content[0], content[1], content[2]


def main():
    content = requests.get("http://192.168.4.1").json()
    time_stamp, should_be_position, actually_position = translate_into_list(content)
    draw_graphics(time_stamp, should_be_position, actually_position)


if __name__ == "__main__":
    main()

Code: Alles auswählen

t = now()
while True:
    tuwas() # y
    t += interval
    sleep(t - now()) # hier entsteht x, aber korrigiert sich ja wieder im nächsten sleep.