LED soll blinken während Schrittmotor dreht!!

  • Hallo Leute,
    Bin neu hier und beschäftige mich erst seit ein paar Monaten mit dem RasPi und Python.
    Ich baue mir einen Schrittmotorbetriebenen Kameraslider und hab ja schon einige Grundfunktionen zum laufen gebracht. Ich weiß das das Programm noch einige Verbesserungen nötig hat, aber momentan läuft es so, bis auf mein Problem mit dem blinken.

    Ich will das eine Tastenfeldbeleuchtung während der Motor dreht, blinkt.
    Hab die Stellen markiert (############!!!!!!...).

    Leider bleibt mein Programm an der stelle hängen, was ja irgendwie logisch ist, aber ich finde keine lösung.

    Ich hab schon ein extra skript geschrieben, was durch subprozess aufgerufen wird, aber das haut mir scheinbar meinen Arbeitsspeicher voll. Oder was auch immer, jedenfalls bremst es alles aus, der Motor ruckelt und nichts blinkt.

    Verbesserungsvorschläge erwünscht!!! ;)

    Vielen Dank für eure Hilfe

    Ps.: "Anfänger"

    Hauptprogramm "auswahl1.py":
    [code=php]
    #!/usr/bin/python
    # coding: utf-8
    import RPi.GPIO as GPIO
    import time
    import math
    import sys
    import subprocess


    GPIO.setmode(GPIO.BCM)
    GPIO.setwarnings(False)

    ## Pin- und GPIOzuweisung
    A_1_pin = 12 # Motorspule A1
    A_2_pin = 16 # Motorspule A2
    B_1_pin = 20 # Motorspule B1
    B_2_pin = 21 # Motorspule B2
    s1 = 24 # Bestätigungstaste (momentan rechtslauf)
    s2 = 27 # Return-Taste (momentan lingslauf)
    s9 = 18 # Schalter für Voll- oder Halbschritte
    stop_r = 22 # Endschalter rechts
    stop_l = 23 # Endschalter links
    ref = 6 #Joystick Taster zur referenzfahrt
    bl_led = 4 # Tastenfeldbeleuchtung

    ##----------GPIO als Aus- oder Eingänge deklarieren-----------
    ## Ausgänge für Motor zurückgesetzt
    GPIO.setup(A_1_pin, GPIO.OUT)
    GPIO.setup(A_2_pin, GPIO.OUT)
    GPIO.setup(B_1_pin, GPIO.OUT)
    GPIO.setup(B_2_pin, GPIO.OUT)
    GPIO.setup(bl_led, GPIO.OUT)

    GPIO.output(A_1_pin, GPIO.LOW)
    GPIO.output(A_2_pin, GPIO.LOW)
    GPIO.output(B_1_pin, GPIO.LOW)
    GPIO.output(B_2_pin, GPIO.LOW)
    GPIO.output(bl_led, GPIO.LOW)

    ## Eingänge (Pull down)
    GPIO.setup(s1, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    GPIO.setup(s2, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    GPIO.setup(s9, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    GPIO.setup(ref, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    GPIO.setup(stop_r, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    GPIO.setup(stop_l, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)


    ## ruft andere Scripte auf.
    subprocess.Popen(['python', 'ref_rechts_led.py'], stdout = subprocess.PIPE)

    bl_start = False
    def blinken(bl_start):
    while bl_start == True:
    GPIO.output(bl_led, GPIO.HIGH)
    time.sleep(0.4)
    GPIO.output(bl_led, GPIO.LOW)
    time.sleep(1.3)

    def rechts():
    blinken(True) #################!!!!!!!!!!! Ab hier soll es blinken
    from motor import Motor # ruft die Klasse "Motor" in modul motor auf (instanz)
    if input9 == False:
    sequenz = True
    else:
    sequenz = False
    print'Rechts'
    m1 = Motor(int(steps), float(delay), sequenz, coil, stop_r, stop_l)
    m1.rechts()
    m1.step = '0000'
    m1.setze_step(m1.step)
    blinken(False) ##################!!!!!!!!!!! bis hier!!


    def links():
    blinken(True) #################!!!!!!!!!!! Ab hier soll es blinken
    from motor import Motor # ruft die Klasse "Motor" in modul motor auf (instanz)
    if input9 == False:
    sequenz = True
    else:
    sequenz = False
    print'Links'
    m2 = Motor(int(steps), float(delay),sequenz, coil, stop_r, stop_l)
    m2.links()
    m2.step = '0000'
    m2.setze_step(m2.step)
    blinken(False) ##################!!!!!!!!!!! bis hier!!


    def referenz():
    blinken(True) #################!!!!!!!!!!! Ab hier soll es blinken
    from motor import Motor # ruft die Klasse "Motor" in modul m$
    if input9 == False:
    sequenz = True
    else:
    sequenz = False
    ref1 = Motor(int(steps), float(delay),sequenz, coil, stop_r, stop_l)
    ref1.referenz()
    ref1.step = '0000'
    ref1.setze_step(ref1.step)
    blinken(False) ##################!!!!!!!!!!! bis hier!!


    ## Testschleife
    while True:
    # delay = raw_input("Verzögerung zwischen den Schritten (Sekunden)?")
    # steps = raw_input("Wie viele Schritte? ")
    delay = 0.005 # Statt der Eingabe oben
    steps = 100 # Statt der Eingabe oben
    coil = [A_1_pin,A_2_pin,B_1_pin,B_2_pin] # Ausgänge zum Schrittmotor
    print 'start'
    while True:
    ## Tasterinput durch GPIO
    input1 = GPIO.input(s1)
    input2 = GPIO.input(s2)
    st_r = GPIO.input(stop_r)
    st_l = GPIO.input(stop_l)
    refer = GPIO.input(ref)
    input9 = GPIO.input(s9)
    ## Rechts
    if input1 == False and st_r == True:
    rechts()
    while input1 == False:
    input1 = GPIO.input(s1)

    # Links
    elif input2 == False and st_l == True:
    links()
    while input2 == False:
    input2 = GPIO.input(s2)


    # Referenzfahrt
    elif refer == True:
    referenz()
    while refer == False:
    refer = GPIO.input(ref)
    [/php]


    Motorinstanz "motor.py":
    [code=php]

    #!/usr/bin/python2
    # coding: utf-8
    import RPi.GPIO as GPIO
    import sys
    import time

    GPIO.setmode(GPIO.BCM)
    GPIO.setwarnings(False)


    class Motor():
    def __init__(self, steps, delay, sequenz, coil, stop_r, stop_l):
    self.sequenz = sequenz
    self.steps = steps
    self.delay = delay
    self.rechtslauf = False
    self.linkslauf = False
    self.coil = coil
    self.step = '0000'
    self.setze_step(self.step)
    if sequenz == True:
    self.reseq = ['1010', '1000','1001','0001','0101', '0100','0110','0010'] # Halbschritte
    self.liseq = list(self.reseq) # Kopiert vorwärtsliste
    self.liseq.reverse() # Liste läuft rückwärts ab
    else:
    self.reseq = ['1010','1001','0101','0110'] # Ganze schritte
    self.liseq = list(self.reseq) # Kopiert vorwärtsliste
    self.liseq.reverse() # Liste läuft rückwärts ab
    self.stop_r = stop_r
    self.stop_l = stop_l
    #----------GPIO als Aus- und Eingänge deklarieren-----------
    # Ausgänge
    GPIO.setup(self.coil[0], GPIO.OUT)
    GPIO.setup(self.coil[1], GPIO.OUT)
    GPIO.setup(self.coil[2], GPIO.OUT)
    GPIO.setup(self.coil[3], GPIO.OUT)
    # Eingänge (Pull down)
    GPIO.setup(self.stop_r, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) # Rechter Endschalter
    GPIO.setup(self.stop_l, GPIO.IN, pull_up_down = GPIO.PUD_DOWN) # Linker Endschalter


    # In der Funktione "setze_step" wird s"step" je nach schrittsequenz aufgelöst
    # und den jeweiligen GPIO's ein Boolischer Wert zugewiesen
    def setze_step(self, step):
    GPIO.output(self.coil[0], self.step[0] == '1')
    GPIO.output(self.coil[1], self.step[1] == '1')
    GPIO.output(self.coil[2], self.step[2] == '1')
    GPIO.output(self.coil[3], self.step[3] == '1')


    #-------------Vorwärtsfunktion------------
    def rechts(self):
    self.rechtslauf = True
    if (GPIO.input(self.stop_r) == True):
    for i in range(self.steps):
    for self.step in self.reseq:
    sys.stdout.flush()
    self.setze_step(self.step)
    time.sleep(self.delay)
    if (GPIO.input(self.stop_r) == False):
    break

    #--------------Rückwärtsfunktion----------
    def links(self):
    self.linkslauf = True
    if (GPIO.input(self.stop_l) == True):
    for i in range(self.steps):
    for self.step in self.liseq:
    sys.stdout.flush()
    self.setze_step(self.step)
    time.sleep(self.delay)
    if (GPIO.input(self.stop_l) == False):
    break
    if (GPIO.input(self.stop_l) == False):
    break

    def referenz(self):
    if (GPIO.input(self.stop_r) == True):
    print "Referenzfahrt nach rechts"
    while True:
    for self.step in self.reseq:
    sys.stdout.flush()
    self.setze_step(self.step)
    time.sleep(0.005)
    if (GPIO.input(self.stop_r) == False):
    print "Referenzpunkt erreicht"
    break
    if (GPIO.input(self.stop_r) == False):
    break
    else:
    print("Referenzpunkt bereits erreicht")
    return self
    [/php]

    Einmal editiert, zuletzt von ludl8615 (27. November 2014 um 00:58)

  • Hallo Ludl,

    meines Erachtens ist da ein Denkfehler drin.

    Du rufst erst Motor() auf. Wenn Motor fertig ist, rufst Du blinken() auf.

    Wenn Du willst, dass die LED blinkt, während der Motor in Aktion ist, dann musst Du blinken() innerhalb Motor() aufrufen.

    Dann macht sleep(0.4) innerhalb Blinken auch keinen Sinn.

    Es reicht vollkommen, den Status des zugehörigen GPIO-Pins auf 1 bzuw. 0 zu setzen und nach Ablauf einer bestimmten Strecke / Winkel den Status zu ändern. Auf diese Weise blinkt die LED auch - ohne die Laufzeit zu stören.

    Eine andere Möglichkeit besteht darin, die Routine auszulagern, und diese als Parallelprozes aufzurufen. Am Ende von Motor() muss dann der Status auf 0 gesetzt werden.

    Das Laufzeitverhalten Deiner Blink-Routine

    Code
    def blinken(bl_start):
            while bl_start == True:
                    GPIO.output(bl_led, GPIO.HIGH)
                    time.sleep(0.4)
                    GPIO.output(bl_led, GPIO.LOW)
                    time.sleep(1.3)

    ist auch klar: Die Routine findet kein Ende. Auf welches Ereignis soll denn Blinken jemals ein Ende finden?

    Denke mal über meine Anregungen nach - und sortiere Deine Zeile in einer sinnvolleren Weise - dann wird Dein Programm genau das machen, was Dir vorschwebt.

    Gutes Gelingen!

    Andreas

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

  • Vielen Dank für die schnelle Antwort

    Das blinken() innerhalb von Motor() aufgerufen werden sollte, klingt natürlich logisch!

    Zitat


    Es reicht vollkommen, den Status des zugehörigen GPIO-Pins auf 1 bzuw. 0 zu setzen und nach Ablauf einer bestimmten Strecke / Winkel den Status zu ändern. Auf diese Weise blinkt die LED auch - ohne die Laufzeit zu stören.


    wenn ich das richtig verstehe, verursacht das dann aber je nach drehzahlen unterschiedliche blinkrhythmen.

    Zitat


    Eine andere Möglichkeit besteht darin, die Routine auszulagern, und diese als Parallelprozes aufzurufen. Am Ende von Motor() muss dann der Status auf 0 gesetzt werden.


    gehen wir mal davon aus ich will diesen Weg einschlagen. Wie gestalte und starte ich den Parallelprozess am sinnvollsten?
    Mit subprocess??
    Und wie kann ich auf die "Variablen" von Motor() zugreifen, mit 'from Modul import...'?

    Ich hab schon vieles durchprobiert, aber wie es am besten und wie es überhaupt richtig funktioniert, ist mir noch immer ein Rätsel.
    Natürlich auch ohne mir den speicher voll zu laden..

    Vielen Gruß
    ludl

  • Also zunächst sollte man beachten das Ein Python Script wie ein Programm ist und nacheinander abgearbeitet wird. Ein oben stehender Befehl muss erst beendet werden damit ein nachfolgender ausgeführt wird. Das lässt sich leicht demonstrieren indem man 2 Print Zeilen setzt und dazwischen eine Pausierung einbaut

    Code
    print("erster Befehl")
    time.sleep(10)
    print("zweiter Befehl")


    Der 2.print wird erst nach 10 Sekunden ausgeführt da der time.sleep das gesamte Script blockiert.

    Wenn etwas parallel also gleichzeitig ausgeführt werden soll muss man diese Vorgänge in einem eigenen Prozess auslagern. Stichwort hierfür ist: Threading

    In deinem Script verwendest du eine while Schleife, die alles andere blockiert. Code der unter der While Schleife stehen könnte, würde erst ausgeführt wenn die while beendet/geschlossen wurde.
    Desweiteren verwendest du ebenfalls time.sleep's in deiner Motor Class.

    Bedeutet also das sich diese Abläufe gegenseitig blockieren; wärend der Motor angesprochen wird kann kein weiterer Befehl ausgeführt werden.

    Ein erster Versuch dieses Problem zu lösen wäre also für die blinken() einen eigenen Thread zu starten, damit diese Unabhängig arbeiten kann, denn:
    * Die LED soll blinken sobald sich der Motor bewegt - erst mal egal in welche Richtung

    Da wäre es also Sinnvoll eine Globale Variable zu prüfen ob sich der Motor bewegt und wenn ja blinkt die LED. Das hast du quasi auch schon gemacht, man bräuchte an der Stelle nur noch eine weitere while Schleife damit sich der "Thread" nicht beendet.

    Es sei übrigens auch noch erwähnt das du bezüglich GPIO und Taster/Buttons lieber mit Interrups arbeiten solltest. Guck dazu mal >> hier << (keine Lust mich überall zu wiederholen, deswegen lies dir das da mal durch..)

    Aber nun erst mal zum Code. Ich füg mal nur vor deine while am Ende etwas ein und schreib die blinken() um - ob der Rest so dann noch funktioniert prüf ich jetzt aber nicht..... (da gäbs noch einiges zu optimieren, aber mir jetzt erst mal egal)

    [code=php]
    #!/usr/bin/python
    # coding: utf-8
    import RPi.GPIO as GPIO
    import time
    import math
    import sys
    import subprocess
    import threading


    GPIO.setmode(GPIO.BCM)
    GPIO.setwarnings(False)

    ## Pin- und GPIOzuweisung
    A_1_pin = 12 # Motorspule A1
    A_2_pin = 16 # Motorspule A2
    B_1_pin = 20 # Motorspule B1
    B_2_pin = 21 # Motorspule B2
    s1 = 24 # Bestätigungstaste (momentan rechtslauf)
    s2 = 27 # Return-Taste (momentan lingslauf)
    s9 = 18 # Schalter für Voll- oder Halbschritte
    stop_r = 22 # Endschalter rechts
    stop_l = 23 # Endschalter links
    ref = 6 #Joystick Taster zur referenzfahrt
    bl_led = 4 # Tastenfeldbeleuchtung

    ##----------GPIO als Aus- oder Eingänge deklarieren-----------
    ## Ausgänge für Motor zurückgesetzt
    GPIO.setup(A_1_pin, GPIO.OUT)
    GPIO.setup(A_2_pin, GPIO.OUT)
    GPIO.setup(B_1_pin, GPIO.OUT)
    GPIO.setup(B_2_pin, GPIO.OUT)
    GPIO.setup(bl_led, GPIO.OUT)

    GPIO.output(A_1_pin, GPIO.LOW)
    GPIO.output(A_2_pin, GPIO.LOW)
    GPIO.output(B_1_pin, GPIO.LOW)
    GPIO.output(B_2_pin, GPIO.LOW)
    GPIO.output(bl_led, GPIO.LOW)

    ## Eingänge (Pull down)
    GPIO.setup(s1, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    GPIO.setup(s2, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    GPIO.setup(s9, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    GPIO.setup(ref, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    GPIO.setup(stop_r, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)
    GPIO.setup(stop_l, GPIO.IN, pull_up_down = GPIO.PUD_DOWN)


    ## ruft andere Scripte auf.
    subprocess.Popen(['python', 'ref_rechts_led.py'], stdout = subprocess.PIPE)

    def rechts():
    global blink_start
    blink_start = True
    from motor import Motor # ruft die Klasse "Motor" in modul motor auf (instanz)
    if input9 == False:
    sequenz = True
    else:
    sequenz = False
    print'Rechts'
    m1 = Motor(int(steps), float(delay), sequenz, coil, stop_r, stop_l)
    m1.rechts()
    m1.step = '0000'
    m1.setze_step(m1.step)
    blink_start = False


    def links():
    global blink_start
    blink_start = True
    from motor import Motor # ruft die Klasse "Motor" in modul motor auf (instanz)
    if input9 == False:
    sequenz = True
    else:
    sequenz = False
    print'Links'
    m2 = Motor(int(steps), float(delay),sequenz, coil, stop_r, stop_l)
    m2.links()
    m2.step = '0000'
    m2.setze_step(m2.step)
    blink_start = False


    def referenz():
    global blink_start
    blink_start = True
    from motor import Motor # ruft die Klasse "Motor" in modul m$
    if input9 == False:
    sequenz = True
    else:
    sequenz = False
    ref1 = Motor(int(steps), float(delay),sequenz, coil, stop_r, stop_l)
    ref1.referenz()
    ref1.step = '0000'
    ref1.setze_step(ref1.step)
    blink_start = False


    def Blinken():
    global blink_start
    blink_start = False
    while True:
    while blink_start == True:
    GPIO.output(bl_led, GPIO.HIGH)
    time.sleep(0.4)
    GPIO.output(bl_led, GPIO.LOW)
    time.sleep(1.3)

    try:
    Blinker_thread = threading.Thread(target=Blinken)
    Blinker_thread.start()
    except (KeyboardInterrupt, SystemExit):
    sys.exit()


    ## Testschleife
    while True:
    # delay = raw_input("Verzögerung zwischen den Schritten (Sekunden)?")
    # steps = raw_input("Wie viele Schritte? ")
    delay = 0.005 # Statt der Eingabe oben
    steps = 100 # Statt der Eingabe oben
    coil = [A_1_pin,A_2_pin,B_1_pin,B_2_pin] # Ausgänge zum Schrittmotor
    print 'start'
    while True:
    ## Tasterinput durch GPIO
    input1 = GPIO.input(s1)
    input2 = GPIO.input(s2)
    st_r = GPIO.input(stop_r)
    st_l = GPIO.input(stop_l)
    refer = GPIO.input(ref)
    input9 = GPIO.input(s9)
    ## Rechts
    if input1 == False and st_r == True:
    rechts()
    while input1 == False:
    input1 = GPIO.input(s1)

    # Links
    elif input2 == False and st_l == True:
    links()
    while input2 == False:
    input2 = GPIO.input(s2)


    # Referenzfahrt
    elif refer == True:
    referenz()
    while refer == False:
    refer = GPIO.input(ref)
    [/php]

  • Vielen Dank für deine Hilfe!! :thumbs1:

    Ich denke mal das ich das mit deinem Ansatz schon irgendwie umsetzen kann.

    Was die optimierung angeht, mit der Zeit und der Größe des Projekts werde ich da sicher noch einiges ändern oder verbessern. "Learning by doing"
    Solange euch sonst nichts gravierendes aufgefallen ist, bin ich mit meiner Umsetzung erstmal zufrieden. Hab wie gesagt erst vor ein paar Monaten damit angefangen, und meine siemens s7 (FUP) kenntnisse heffen da auch nicht unbedingt weiter. .:s

    Ich melde mich dann nochmal falls es funktioniert oder ich im schlimmsten Fall wieder hängen bleibe.

    Gruß
    ludl :cool:

  • und warum keine Blink LED die nur an den PWM Impulsen lauscht oder gar bei Motor ON eingeschaltet wird und bei Motor OFF abgeschaltet wird?

    lasst die PIs & ESPs am Leben !
    Energiesparen:
    Das Gehirn kann in Standby gehen. Abschalten spart aber noch mehr Energie, was immer mehr nutzen. Dieter Nuhr
    (ich kann leider nicht schneller fahren, vor mir fährt ein GTi)

  • verdammt ich hätte das nicht als Frage stellen sollen, ich wollte darauf keine Antwort!


    Weil das wieder eine zusätzliche Anschaffung bedeuten würde?

    für manche ist das aber der schnellere Lösungsweg, ein Teil kaufen was funktioniert als nie die Lösung zu finden.


    Man muss nicht alles via Hardware lösen wenns auch ne einfache Softwarelösung gibt

    ist das so?

    blinkt dann diese Softwarelösung weiter oder nicht wenn der Motor durch Blockade nicht mehr dreht?

    wie definiert ihr einfache Softwarelösung? :s

    lasst die PIs & ESPs am Leben !
    Energiesparen:
    Das Gehirn kann in Standby gehen. Abschalten spart aber noch mehr Energie, was immer mehr nutzen. Dieter Nuhr
    (ich kann leider nicht schneller fahren, vor mir fährt ein GTi)

  • jar: Wie wärs wenn du dir den Code einfach mal anguckst.

    Es sind kaum weitere Zeilen anzupassen und es funktioniert tadellos.

    Wenn du sowas nicht verstehst dann erstell dir doch bitte einen eigenen Thread in dem man Dir das dann genauer erklären könnte. Sowas aber immer wieder in Fremden Threads zu hinterfragen ist unhöflich - und langsam aber sicher auch nervig

    Deshalb kurz und knapp:

    ist das so?

    JA !


  • jar: Wie wärs wenn du dir den Code einfach mal anguckst.

    und wie stellt der Code fest ob der Motor blockiert und nicht mehr dreht?


    Sowas aber immer wieder in Fremden Threads zu hinterfragen ist unhöflich - und langsam aber sicher auch nervig

    nervig ist doch das DU Fragen beantwortest die ich DIR nicht stelle!

    und nun erkläre bitte wie der Code die Nichtdrehung bei Blockade in keine blinkende LED umsetzt, diesmal stelle ich die Frage dir da du ja immer eine Antwort weisst.

    lasst die PIs & ESPs am Leben !
    Energiesparen:
    Das Gehirn kann in Standby gehen. Abschalten spart aber noch mehr Energie, was immer mehr nutzen. Dieter Nuhr
    (ich kann leider nicht schneller fahren, vor mir fährt ein GTi)

  • Wenn das denn überhaupt nötig ist zu prüfen, kann man den Code entsprechend anpassen... Ich frag mich aber auch gerade wie DEIN Vorschlag das bewerkstelligen sollte, was du Mir jetzt hier vorwirfst nicht beachtet zu haben

  • Haut euch nicht die Köpfen ein, ich mach das ganze ja um hauptsächlich in Python einzusteigen und ein Projekt damit umzusetzen.
    Wenn das blinken so nicht hin haut oder ich mir später noch überlege das eine Hardwareseitige "Überwachung" sinnvoll ist, kann ich das immer noch später umsetzen. Momentan geht es mir ja rein um den Aufbau und den Syntax eines Programms.

    Andere Vorschläge werden zur Kenntnis genommen und überdacht. Trotzdem kein Grund sich zu zerfleischen.
    Komm wahrscheinlich erst wieder Sonntag oder Montag zum programmieren, muss mich mal um meine Freundin kümmern. :heart:
    Allen ein schönes Wochenende! ;)

    Vielen Dank für eure Hilfe!!!

    Einmal editiert, zuletzt von ludl8615 (27. November 2014 um 20:41)

  • Hallo Jar,

    das mit der Blink-LED ist eine gute Idee. Dies hätte den Vorteil, dass die gesamte Rechenleistung auf die Motorsteuerung entfällt und somit keine Ressourcen nur für das Blinken drauf geht.

    Warum kam ich nicht drauf? :s :wallbash: :thumbs1:

    Beste Grüße

    Andreas

    Ich bin wirklich nicht darauf aus, Microsoft zu zerstören. Das wird nur ein völlig unbeabsichtigter Nebeneffekt sein.
    Linus Torvalds - "Vater" von Linux

    Linux is like a wigwam, no windows, no gates, but with an apache inside dancing samba, very hungry eating a yacc, a gnu and a bison.

    • Offizieller Beitrag

    Dran denken, man kann threads nicht beenden, also entweder das Teil blinkt eine zeit x oder du musst dich in multiprocessing probieren. prinzipiell das gleiche, aber multiprocesse kann man beenden.

    Der Unterschied zwischen Genie und Wahnsinn definiert sich im Erfolg.


  • Dran denken, man kann threads nicht beenden, also entweder das Teil blinkt eine zeit x oder du musst dich in multiprocessing probieren.

    dbv:huh:

    Ich glaub du hast den Code nicht wirklich gelesen, kann das sein?


    Noch mal zum Mitdenken ein einfaches Beispiel was ihr selber testen könnt:

    [/spoiler]


    Und was für Rechenleistung meinst du Andreas :huh: die 0,2% die dadurch mehr beansprucht werden kann der PI nicht verkraften oder wie :-/


  • Mag mir jetzt einer von euch Schlaubergern erklären was da abläuft :huh:

    nö nicht wirklich solange diese unordentliche Sprache gewählt ist.


    Hoffentlich macht's währenddessen *klick* :fies:

    aber ich versuche mal klicken zu lassen.......

    Schrittmotor impliziert bei mir erst mal Schritte,

    diese werden vom PI, Atmel oder sonst wem generiert (früher machte das ein IC)

    wenn ich nun diese Schritte einfach anzapfe, per Draht brauche ich nicht mal Software oder Task oder Ports, die schicken Pulse durch die geschalteten Schritte lassen eine LED ganz von alleine blinken solange sie laufen, wenn der Motor stoppt, keine Pulse mehr kein blinken, wer will mir da was vonn Software und Task oder Threads erzählen oder gar Rechenleistung?

    Die 3-10mA die ich für die LED dem Motor klaue dürften den kaum jucken.

    Sollte der Motor zu schnell laufen und das Blinken in konstantes Licht überwechseln weil wir das schnelle Blinken nicht erkennen dann schaltet man einen Frequenzteiler vor.

    lasst die PIs & ESPs am Leben !
    Energiesparen:
    Das Gehirn kann in Standby gehen. Abschalten spart aber noch mehr Energie, was immer mehr nutzen. Dieter Nuhr
    (ich kann leider nicht schneller fahren, vor mir fährt ein GTi)

  • Servus,
    Also, jetzt läuft alles wie gewollt!! Habt mir extrem weiter geholfen.
    Ich hab aus "subprocess.Popen" auch noch einen eigenen thread gemacht. subprocess.Popen hat das Programm unglaublich ausgebremst, sodass mein LCD Display -was ich über den I2C bus eingebunden hab- in Zeitlupe geschrieben hatte.
    Jetzt kommt nur noch ein Joystick dazu, mit dem man den Schlitten manuell verfahren kann.

    Ich stell das programm jetzt nicht online, da es sehr große Ausmaße angenommen hat. Bin Gerade noch dabei es in Kleinere, übersichtlichere Teile zu zerlegen, damit ich auch später schnell Durchblicke.

    Schönen Gruß und nochmal Danke an alle!
    ;)

Jetzt mitmachen!

Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!