Wie kompiliert man MicroPython vom Quellcode selbst?

[__deets__]

Das der NodeMCU noch eine Schutzdiode in der 5V Versorgung Richtung USB Port hat. Und darum mit externen 5V nicht läuft.

Ich löte dem dafür dann immer eine extra Stecker an den 3V3 LDO der die Spannung für den Kern von 5V runterbringt. Zb hier zu sehen: https://www.dropbox.com/s/eplavcbnpzvuv ... V.PNG?dl=0

Achtung: du musst das selbst ausmessen, wo genau bei deinem Modell die 5V Anliegen!

[Dennis89]

Oh mein Gott, das ist ja wie Lotto spielen, ob das bei mir funtioniert.
Ich hab zwar den Maiskolben mit seiner spitzen Lötspitze, aber ich bin kein Chirurg.
Könnte ich auch einfach ein USB-Kabel abschneiden und den Stecker in die Buchse und auf die Kabel 5V geben? Das wäre auch für den Fall, dass man den mal tauschen muss einfacher.

Vielen Dank für deine schnelle Antwort.

Grüße
Dennis

[__deets__]

Klar, das geht auch.

[Dennis89]

Oh man, Kabel abgeschnitten leider kein Erfolg.
Aber ich habe die Lösung gefunden, davon hatten wir es auch neulich und zwar die Strapping Pins. Die TX-Leitung vom Display war auf GPIO 12 angeschlossen und das ist ein strapping Pin. Wenn ich den ausstecke funktioniert es, egal ob ich der ESP die Spannung über den 5V-Pin oder den USB-Stecker bekommt. Schade um das Kabel, aber immerhin wieder schlauer geworden.

Viele Grüße
Dennis

[Dennis89]

Hallo,

heute mal nochmal abseits von Python eine Frage. Ich will meine Schaltung jetzt weg vom Steckbrett haben und auf eine Platine löten. Bei den Überlegungen wurde mir schnell klar, dass wenn ich das Layout der Platine nicht ordentlich plane, das Chaos beim Löten schon vorprogrammiert ist (wenigstens ist das Wort "programmiert" in der Frage enthalten).
Denn Schaltplan habe ich mit Fritzling erstellt und das bietet auch die Möglichkeit Platinen zu desginen und sogar fertigen zu lassen. Das wäre eigentlich echt cool, wenn ich die Platine bekomme und nur noch die Bauteile einlöten muss. Sieht auch besser aus, wie wenn ich eine universelle Lochrasterplatine nehme und die Bauteile einlöte und mit Draht verbinde.
Ich kann nur nicht alles auf die Platine drauf machen, für Taster, Sensoren etc. will ich Steckverbindungen schaffen. Dafür müsste ich jetzt extra Fritzlingbauteile erstellen. Und an dieser Stelle wollte ich mal kurz nachfragen, was ihr für Software in solchen Situationen nutzt? Gibt es was besseres, geschickteres und wie sind eure Erfahrungen? Also das es professionielle Software gibt, die man sich kauft, wenn man damit Geld verdient ist mir klar. Die Vergleiche sollten sich dann schon in dem Budge von Fritzling bewegen.

Danke und Grüße
Dennis

[__deets__]

Ich mache das mit KiCAD. Finde ich super. Ist aber ein bisschen Aufwand sich darin einzuarbeiten.

[Dennis89]

Danke, es lädt gerade runter und ich schaue es mir morgen mal an.
Es gibt zum Glück ein "Getting started", dann klicke ich nicht gleich ganz so planlos rum.

Wenn ich ein Layout fertig habe (egal mit welchem Programm) dann kann ich das hier gerne zeigen und auch begründen wieso ich mich dann für das Programm entschieden habe.

Ansonsten soll morgen wohl auch der Analog-to-digital-converter eintreffen, dann kann ich den noch einbauen und programmieren und wenn dass dann funktioniert, wäre ich mit dem Programmieren fertig.

Grüße
Dennis

[Dennis89]

Hallo,

der ASD1015 ist angekommen und funktioniert einwandfrei. Jetzt ist meine Anzeige stabil. Vielen Dank für den Hinweis.
Leider hat sich jetzt noch ein anderes Problem eingeschlichen. Ich kann einstellen um wieviel Grad sich die Schweißachse drehen soll. Wenn das Schweißgerät aus ist, soll sich die Schweißachse aber wieder auf 0° bzw. 360° drehen, damit man das Werkstück angenehmer entnehmen kann. Das hat bis heute auch funktioniert und funktioniert jetzt nur noch zufällig.
Ich habe mir die Werte der aktuellen Position ausgeben lassen und teilweise fehlen in paar und dann dreht der Motor ununterbrochen im Kreis. Kann dass sein dass der I2C-Bus jetzt irgendwelche Ressourcen benötigt und mir dadurch mein Prozess stört?

Die Funktion, die den Motor stoppen soll wäre diese:

Code: Alles auswählen

    def stop_welding(self, stop_to_initial=False):
        self.welding_axis.duty(0)
        self.welding_machine.off()
        sleep(1)
        if not stop_to_initial and self.actually_welding_position != 360:
            self.welding_axis.duty(-60 * self.direction)
            while True:
                if self.actually_welding_position in [360, 0]:
                    self.welding_axis.duty(0)
                    break
        self.counter.reset()

Die ganze 'main.py':

Code: Alles auswählen

from time import sleep, ticks_diff, ticks_us

from esp32 import MCPWM, PCNT
from LargeCounter import LargeCounter
from machine import ADC, Pin, I2C
from ControlDisplay import Display
from ads import ADS1015
import _thread

RX_PIN = 34
TX_PIN = 13

ENCODER_PINS = [2, 15]

REFERENCE_SWITCH_PIN = 4
END_POSITION_PINS = {"left": 18, "right": 19}

AUTOMATIC_BUTTON_PIN = 35
SIMULATE_BUTTON_PIN = 33
START_BUTTON_PIN = 14
ROTATE_BUTTON_PIN = 39

SDA = 21
SCL = 22

STATUS_LED_PIN = 32
WELDING_MACHINE_PIN = 26

PNEUMATIC_CYLINDER_PINS = {"left": 25, "right": 27}
PWM_PINS = {"welding_axis": [5, 16], "rotation_axis": [17, 23]}

ENCODER_RESOLUTION = 5000
# Welding-angle in °, speed in %, time before start welding in s
MAX_VALUES_TO_TRANSLATE_DIGITAL_VALUE = [550, 100, 5]
POSITION_MACHINE_START = "left"
RATIO = 152 / 63
# For example 5e6 = 5 seconds
APPLY_POSITION = 3e6


class WeldingControl:
    def __init__(self):
        self.display = Display(TX_PIN, RX_PIN)
        i2c = I2C(0, sda=Pin(SDA), scl=Pin(SCL))
        self.turn_switches = ADS1015(i2c, gain=1)
        self.start = Pin(START_BUTTON_PIN, Pin.IN, Pin.PULL_DOWN)
        self.rotate_workpiece = Pin(ROTATE_BUTTON_PIN, Pin.IN, Pin.PULL_DOWN)
        self.simulate_mode = Pin(SIMULATE_BUTTON_PIN, Pin.IN, Pin.PULL_DOWN)
        self.automatic_mode = Pin(AUTOMATIC_BUTTON_PIN, Pin.IN, Pin.PULL_DOWN)
        self.welding_axis = MCPWM(0)
        self.welding_axis.bind(
            Pin(PWM_PINS["welding_axis"][0]), Pin(PWM_PINS["welding_axis"][1])
        )
        self.turning_axis = MCPWM(3)
        self.turning_axis.bind(
            Pin(PWM_PINS["rotation_axis"][0]), Pin(PWM_PINS["rotation_axis"][1])
        )
        self.welding_machine = Pin(WELDING_MACHINE_PIN, Pin.OUT)
        self.cylinders = {
            position: Pin(pin, Pin.OUT)
            for position, pin in PNEUMATIC_CYLINDER_PINS.items()
        }
        self.status_led = Pin(STATUS_LED_PIN, Pin.OUT)
        self.machine_start_reference = Pin(
            REFERENCE_SWITCH_PIN, Pin.IN, Pin.PULL_DOWN
        )
        self.end_positions = {
            position: Pin(END_POSITION_PINS[position], Pin.IN)
            for position in END_POSITION_PINS
        }
        encoder = PCNT(0, Pin(ENCODER_PINS[0]), Pin(ENCODER_PINS[1]))
        self.counter = LargeCounter(encoder)

        try:
            self.active_end_position = [
                position
                for position in self.end_positions
                if self.end_positions[position].value()
            ][0]
        except IndexError:
            self.active_end_position = None
        self.welding_axis.duty(0)
        self.status_led.off()
        for cylinder in self.cylinders.values():
            cylinder.off()
        sleep(1)

    @property
    def actually_welding_position(self):
        # position in angle
        return (
                self.direction * 360 * self.counter.counter() // ENCODER_RESOLUTION // RATIO
        )

    @property
    def direction(self):
        return 1 if self.active_end_position == POSITION_MACHINE_START else -1

    @property
    def time_before_start(self):
        return self.translate_measure_value(
            self.turn_switches.read(channel1=1),
            MAX_VALUES_TO_TRANSLATE_DIGITAL_VALUE[2],
        )

    @property
    def welding_angle(self):
        return self.translate_measure_value(
            self.turn_switches.read(channel1=2),
            MAX_VALUES_TO_TRANSLATE_DIGITAL_VALUE[0],
        )

    @property
    def welding_speed(self):
        return self.translate_measure_value(
            self.turn_switches.read(channel1=0),
            MAX_VALUES_TO_TRANSLATE_DIGITAL_VALUE[1] * self.direction,
        )

    @staticmethod
    def translate_measure_value(value, reference_value):
        # 1610 = max. value ads1015.read()
        # Weldingspeed could be negative because of direction
        value = max(value, 0)
        if abs(reference_value) > 10:
            return reference_value * value // 1610
        else:
            return round(reference_value * value / 1610, 1)

    def check_machine_position(self):
        self.turning_axis.duty(50)
        if self.end_positions[POSITION_MACHINE_START].value():
            self.turning_axis.duty(0)
            self.active_end_position = POSITION_MACHINE_START
            return True

    def control_cylinder(self, state, position):
        if state == "out":
            self.cylinders[position].on()
        else:
            self.cylinders[position].off()

    def control_welding_process(self):
        self.status_led.off()
        welding_success = self.do_welding()
        if welding_success:
            self.stop_welding()
            if self.automatic_mode.value():
                self.control_workpiece_rotation()
                sleep(1)
                welding_success = self.do_welding()
                if welding_success:
                    self.stop_welding()
                    self.control_workpiece_rotation()
            self.status_led.on()

    def control_workpiece_rotation(self):
        self.control_cylinder("in", self.active_end_position)
        sleep(1)
        self.rotate()
        sleep(1)
        self.control_cylinder("out", self.active_end_position)

    def do_welding(self):
        if not self.end_positions[self.active_end_position].value():
            self.stop_welding(stop_to_initial=True)
            self.set_back_to_initial_mode()
            return False
        if not self.simulate_mode.value():
            self.welding_machine.on()
        start = ticks_us()
        while True:
            if not self.end_positions[self.active_end_position].value():
                self.stop_welding(stop_to_initial=True)
                self.set_back_to_initial_mode()
                return False
            if ticks_diff(ticks_us(), start) > self.time_before_start * 1e6:
                break
            sleep(0.01)
        self.welding_axis.duty(self.welding_speed)
        while True:
            if not self.end_positions[self.active_end_position].value():
                self.stop_welding(stop_to_initial=True)
                self.set_back_to_initial_mode()
                return False
            if self.actually_welding_position >= self.welding_angle:
                break
            self.welding_axis.duty(self.welding_speed)
            sleep(0.01)
        return True

    def initial_machine(self):
        if self.active_end_position is None:
            self.control_cylinder("in", "left")
            self.control_cylinder("in", "right")
            sleep(1)
            while True:
                if self.check_machine_position():
                    sleep(0.5)
                    self.control_cylinder("out", self.active_end_position)
                    sleep(1)
                    break
                sleep(0.1)
        else:
            self.control_cylinder("out", self.active_end_position)
        while not self.initial_welding_axis():
            pass

    def initial_welding_axis(self):
        initial_status = None
        self.welding_axis.duty(100)
        while True:
            if self.machine_start_reference.value():
                self.welding_axis.duty(0)
                self.display.show_info_text(
                    "Position ändern: Start drücken --- Position bestätigen: Start 3s gedrückt halten")
                while True:
                    if self.start.value():
                        timestamp = ticks_us()
                        while self.start.value():
                            time_delta = ticks_diff(ticks_us(), timestamp)
                            if time_delta >= APPLY_POSITION:
                                initial_status = True
                                self.display.show_info_text("Maschine ist einsatzbereit")
                                break
                            # Show text only if user held the button, not if just pressed shortly
                            if time_delta > 5e5:
                                self.display.show_info_text(
                                    "Verbleibende Zeit: {:.1f}s".format((APPLY_POSITION - time_delta) * 1e-6))
                        if initial_status:
                            self.counter.reset()
                            return True
                        else:
                            self.display.show_info_text(
                                "Position ändern: Start drücken --- Position bestätigen: Start 3s gedrückt halten")
                            self.welding_axis.duty(80)
                            sleep(0.5)
                            while True:
                                if self.machine_start_reference.value():
                                    self.welding_axis.duty(0)
                                    initial_status = False
                                    break

            sleep(0.01)

    def monitor_input_devices(self):
        while True:
            try:
                if not self.end_positions[self.active_end_position].value():
                    self.set_back_to_initial_mode()
            except KeyError:
                pass
            if self.simulate_mode.value():
                self.welding_machine.off()
            if self.start.value():
                self.switching_start_stop()
            if self.rotate_workpiece.value() and self.status_led.value():
                self.display.show_info_text("Vorsicht Maschine dreht sich")
                self.status_led.off()
                self.control_workpiece_rotation()
                sleep(1)
                self.status_led.on()
            self.show_info_text()
            sleep(0.1)

    def rotate(self):
        for end_position in self.end_positions:
            if self.active_end_position != end_position:
                break
        self.turning_axis.duty(
            50 if self.active_end_position == POSITION_MACHINE_START else -50
        )
        sleep(1)
        while True:
            if self.end_positions[end_position].value():
                self.turning_axis.duty(0)
                self.active_end_position = end_position
                break
            sleep(0.1)

    def set_back_to_initial_mode(self):
        self.display.show_info_text("Positionsfehler. Start-Button für erneute Referenzfahrt drücken.")
        self.status_led.off()
        self.cylinders[self.active_end_position].off()
        self.active_end_position = None
        self.wait_for_initial()
        self.initial_machine()

    def show_info_text(self):
        if self.simulate_mode.value():
            simulate = "Simulationsmodus ist AN"
        else:
            simulate = "Simulationsmodus ist AUS"
        if self.automatic_mode.value():
            automatic = "Automatikmodus ist AN"
        else:
            automatic = "Automatikmodus ist AUS"
        self.display.show_info_text("{} - {}".format(simulate, automatic))

    def stop_welding(self, stop_to_initial=False):
        self.welding_axis.duty(0)
        self.welding_machine.off()
        sleep(1)
        if not stop_to_initial and self.actually_welding_position != 360:
            self.welding_axis.duty(-60 * self.direction)
            while True:
                if self.actually_welding_position in [360.0, 0.0]:
                    self.welding_axis.duty(0)
                    break
        self.counter.reset()

    def switching_start_stop(self):
        if not self.status_led.value():
            self.stop_welding()
            self.status_led.on()
        else:
            self.control_welding_process()

    def update_display(self):
        while True:
            self.display.update_controller(
                {'speed': self.welding_speed, 'time': self.time_before_start, 'angle': self.welding_angle})
            sleep(0.1)

    def wait_for_initial(self):
        while not self.start.value():
            sleep(0.1)


def main():
    welding_control = WeldingControl()
    welding_control.display.show_info_text("Start drücken für Referenzfahrt")
    welding_control.wait_for_initial()
    welding_control.display.show_info_text("Maschine wird vorbereitet")
    welding_control.initial_machine()
    _thread.start_new_thread(welding_control.update_display, ())
    welding_control.status_led.on()
    while welding_control.start.value():
        pass
    welding_control.monitor_input_devices()


if __name__ == "__main__":
    main()

Die Bibliothek für den ASD1015 wäre diese.

Weil ich es glaub hier noch nicht gezeigt habe, auf jeden Fall die entgütige Version noch nicht, hier ist meine ControlDisplay.py:

Code: Alles auswählen

from Nextion import Nextion

NUMBER_OF_PICTURES = 25
CONTROLLER_TO_PICTURE_SETTINGS = {
    "speed": {
        "add_to_picture_number": 0,
        "max_value": 100,
        "start_picture_number": 1,
        "picture_position_x": 0,
        "picture_position_y": 230,
        "text_position": 80
    },
    "time": {
        "add_to_picture_number": 25,
        "max_value": 5,
        "start_picture_number": 26,
        "picture_position_y": 230,
        "picture_position_x": 267,
        "text_position": 340
    },
    "angle": {
        "add_to_picture_number": 50,
        "max_value": 550,
        "start_picture_number": 51,
        "picture_position_y": 219,
        "picture_position_x": 529,
        "text_position": 605
    },
}


class Display:
    def __init__(self, tx_pin, rx_pin):
        self.display = Nextion(tx_pin, rx_pin, 9600)
        self.last_values = {}
        self.last_picture_number = {}

    def update_controller(self, values):
        for controller, factors in CONTROLLER_TO_PICTURE_SETTINGS.items():
            value = abs(values[controller])
            if value != self.last_values.get(controller):
                picture_number = translate_to_picture_number(factors, value)
                if picture_number != self.last_picture_number.get(controller):
                    self.display.cmd(
                        "pic {},{},{}".format(factors["picture_position_x"],factors["picture_position_y"], picture_number)
                    )
                    self.last_picture_number[controller] = picture_number
                self.display.cmd('xstr {},300,114,60,1,65535,0,1,1,0,"{}"'.format(factors["text_position"], value))
                self.last_values[controller] = value

    def show_info_text(self, text):
        self.display.cmd('xstr 8,167,770,43,2,65535,0,1,1,0,"{}"'.format(text))


def translate_to_picture_number(factors, value):
    picture_number = factors["add_to_picture_number"] + (
            NUMBER_OF_PICTURES * value // factors["max_value"]
    )
    return max(int(picture_number), factors["start_picture_number"])

Mit "KiCAD" habe ich heute morgen schon angefangen und mache nachher weiter. Bis jetzt kann ich aber noch nicht sagen, was ich nachher entgültig verwende.

Grüße
Dennis

[__deets__]

Also mir wäre da kein Zusammenhang erklärbar. Da hilft nur klassisches Ausschlussverfahren - runterdummen des Programms & schauen, ob & welche Komponenten gemeinsam funktionieren.

[Dennis89]

Okay, dann muss ich das so mal testen.

Dachte mir auch schon, dass das vielleicht schon immer nur zufällig funktioniert hat und es mir einfach erst heute aufgefallen ist. (Obwohl ich es oft versucht habe) Und das vielleicht der Thread stört, der ununterbrochen schaut ob das Display aktuallisiert werden muss.

Danke und Grüße
Dennis

[Dennis89]

Guten Abend,

habe mit KiCAD meine benötigten Symbole und Footprints erstellt, den Schaltplan erstellt und designe zur Zeit die Platine. Also mit dem Programm kann ich mich ganz gut anfreunden, aber Spass ist auch etwas anderes
@__deets__ kam das bei dir auch vor, dass du den Schaltplan wieder ändern musstest, weil sich sonst die Leiterbahnen kreuzen würden bzw. weil eine Verbindung gar nicht möglich wäre? Oder gehst du da ganz anders vor?

Grüße
Dennis

[__deets__]

Also grundsätzlich ist es schon ein guter Ansatz, bei frei wählbaren Pins die nach routing Geometrie auszurichten. Aber immer geht das nicht, und im Zeitalter billiger 4-lagiger Platinen hat man so viel Freiheiten, da kommt man auch ohne hin.

[Dennis89]

Guten Morgen,

4-lagiger Platinen

oh das hört sich nach einem Stichwort an, nach dem ich mal in den Einstellungen suchen muss.


Vielen Dank und Grüße
Dennis

[Dennis89]

Guten Abend,

zwischen durch habe ich gezweifelt, ob ich es noch erleben werde
Hier mal meine erstes Platinenlayout:
https://www.dropbox.com/s/sjczo1d2ze06a ... t.PNG?dl=0

Ich hatte nicht wirklich einen Plan wie ich sinnvoll anfangen soll und das ist jetzt entstanden. Ich nutze zwei Leiterbahnen, rot ist oben und blau ist unten. Es fehlen noch zwei Löcher, damit ich mein Netzteil anschließen kann. Das mache ich morgen und dann muss ich den Schaltplan noch mal ganz genau prüfen und je nach dem wie ich Lust habe, kann ich die Platine noch verfeinern.
Ich habe da ja einige Stecker drin, da würde ich gern die einzelnen Pins noch beschriften.

Grüße
Dennis

[__deets__]

Ganz gut für den Anfang, aber würde ich noch überarbeiten. Zum einen macht man eigentlich immer eine Massefläche, zb auf der unteren Lage. Besser sogar oben und unten. Dazu ein Polygon (einfach ein Rechteck aufziehen). Die Stromversorgung sollte breiter sein, macht man mit einer Netzklasse. Siehe https://youtube.com/watch?v=mQSgsd_uNSE ... IECMiOmarE - ersteres macht er vor, 2teres ist erwähnt. Diese Flächen reduzieren die Kopplung von Signalen untereinander. Das ist ein komplexes Thema, aber kann auch schon bei dir ein Problem darstellen! Ich habe damit zb schon Fehlkommunikation über UART erzeugt, wund tagelang meinen Kopf gekratzt.

Auch zu sehen, u d ein Fehler bei dir: man benutzt 45 grad Winkel. Nicht 90. Das ist erst bei Höchstfrequenzen ein Thema. Aber es verkürzt die Wege.

Der Wiederstands-Footprint sieht komisch aus. Zu lang. Zu kleine Löcher. Würde ich nochmal ändern. Es fehlt auch die äußere Umrandung, zum CNC cut. Und ein paar Dinge sind mir unklar -hast du mal die Schematic?

[Dennis89]

Guten Morgen,

Danke für deine Hinweise, ich werde mich dran setzen und schauen wie ich das umsetzen kann.
Der Widerstand ist schon etwas länger das stimmt, die Löcher sollten eigentlich passen, aber ich messe noch ein mal nach. Es kann auch sein dass das täuscht, weil ich habe leider ziemlich dicke Pins an den Stecker.
Der weiße Rahmen ist meine Umrandung, den habe ich wie im Getting Started mit dem "Edge.Cut"-Layer gemacht.

Das wäre der Schaltplan im aktuellen Zustand, ich hoffe du findest nicht gleich einen Fehler. Den muss ich auch noch mal kontrollieren und aufräumen.

Grüße
Dennis

[__deets__]

Der ist schwer durchschaubar. Ist natürlich ein Erfahrungs-Ding. Aber zb router man nicht die ganzen Power Leitungen. Sondern benutzt mehr die Power flags. Die ganzen Widerstände sind schwer verständlich. Sind das pull-ups? Mit 220Ohm sind die ziemlich niedrig dimensioniert. 2-10K sind da eher üblich. Man malt auch nicht durch Komponenten wie unten bei Näherungsschalter 1.

Aber das wirklich wichtigste ist dieses Knäuel aufzulösen durch GND und 3V3 Flags. Sonst ist das undurchschaubar & damit auch nicht debugbar.

[Dennis89]

Ich habe mir dein Video angeschaut und bin jetzt dabei die ganze Videoreihe von diesem Herrn anzuschauen.
Im Anschluss werde ich dann den Schaltplan und die Platine überarbeiten. Der Schaltplan ist etwas auf die schnelle entstanden, weil ich mir nicht sicher war ob ich das Programm überhaupt verwenden will. Das rächt sich jetzt natürlich, aber das wusste ich ja.

Das mit den Flags hört sich gut an

Das sollten pull-down Widerstände sein. Vielleicht ist der Fritzing-Schaltplan (nach dem habe ich aufgebaut) etwas übersichtlicher. Aber auch da habe ich keine Flags drin.

Ich weis noch nicht bis wann ich es schaffe, aber die überarbeiteten Versionen folgen

Grüße und Danke
Dennis

[__deets__]

Aber da ist doch bei Endlage zB der R12, klar ein pull-down. Über den du whooping 15mA fließen lässt, wenn der Schalter schließt. Klar ist das nur kurz, aber trotzdem viel zu hoch. Der 10-50 fache wert ist da angezeigt. Gleiche Überlegung zb bei R17.

Mir persönlich fällte es da immer leichter wenn ich pulls wirklich senkrecht platziere. Und natürlich oben oder unten abhängig von ihrer Funktion. Current limiting resistors dann horizontal. Das sind natürlich keine harten Regeln, aber machen mir das Verständnis leichter.

[Dennis89]

Okay, dann ersetze ich die Widerstände gegen 10k Ohm, dann komme ich auf einen Strom von 0,33mA.

Der 10-50 fache wert ist da angezeigt.

Den Satz verstehe ich nicht ganz. Wo wird das angezeigt? Oder ist das Wort "angezeigt" falsch und du meintest dass der Widerstandswert 10-50 mal so hoch sein soll wie jetzt? (Würde zu deiner Aussage mit 2 - 10k Ohm passen).

Ich hatte beim erstellen des Schaltplans eher noch damit zu kämpfen, dass ich das irgendwie halbwegs ansehbar auf ein Blatt bekomme und habe die Bauteile so gedreht wie es dafür nötig war. Aber ich kann versuchen das auch einfließen zu lassen.

Danke und Grüße
Dennis