PWM Stoppt nach einer Zeit

[hellothere]

Hallo,

ich bin noch relativ neu in python und bitte deshalb um Rücksicht. Ich komme aufgrund meines Kenntnisstandes nicht weiter die genaue Problembeschreibung und Fehlermeldung gibt es weiter unten.
Über Hilfe freue ich mich sehr. Auch wenn es mein Problem nicht löst gebt mir bitte Ratschläge, um den Code zu verkürzen/verbessern. Ich weiß das ist an einigen Stellen möglich nur wusste ich nicht wie. Wenn ihr so etwas seht könntet ihr mich ja darauf hinweisen und mir zeigen wie es besser wäre. Jede Hilfe ist willkommen Danke


Ich beschreibe zunächst einmal mein Vorhaben:

Ich möchte gerne automatisiert meinen Nintendo 3ds bedienen, dies habe ich mithilfe von 4 Servos und einer Kamera angeschlossen an den Raspberry Pi realisiert.
Ein Servo bedient dabei immer zwei knöpfe. Wenn er links einen bestimmten winkel erreicht drück er den einen und wenn er rechts einen bestimmten winkel erreicht den anderen. Bei 4 Servos mit jeweils zwei knöpfen, werden also insgesamt 8 knöpfe bedient.
Die servos steuere ich dabei mit einer PWM an.

Nun zur Camera diese macht nach bestimmten abläufen bilder und vergleicht bestimmte pixel werte.

Im Prinzip läuft dabei ein spiel auf dem Nintendo 3ds mit einem Spieler und es soll mithilfe der Kamera z.B. geschaut werden, ob der Spieler nach hin und her bewegen wieder auf der selben Stelle steht. Also macht die Kamera vorher und nachher ein Bild und vergleicht diese.

Mehr ins Detail:
wer sich damit auskennt:
Es handelt sich dabei um das Spiel Alpha Saphir der Pokemonreihe. Es soll dort der Spieler Eier abholen in dem er den NPC anspricht und diese durchs hin und her laufen schlüpfen lassen. Der Spieler kann maximal 5 eier tragen im Programm durch die Variablen platz und p realisiert. diese 5 Eier sollen durchs laufen schlüpfen(ist bei Pokemon so) deshalb wird die variable schlupf oder s hochgezählt. Sind alle geschlüpft(also schlupf = 5) soll das Programm beenden.
Nun zum Problem:

Das Programm läuft einige Zeit (ungefähr 15-20 min) ohne Probleme, aber dann hören die Servos auf sich zu bewegen. Die Funktionen zum servo ansteuern werden noch aufgerufen und durchlaufen ohne einen Fehler auszugeben, aber es findet keine Bewegung der servos mehr statt. Danach wird das Unterprogramm aufgerufen zum Bild machen und er bekommt einen timeout error in der capture Funktion(siehe Fehlermeldung unten).

Meine Vermutung:
aufgrund meines Unwissens schreibt sich irgend ein Speicher voll und die Servos können nicht mehr korrekt angesprochen werden :K am anfang hatte ich noch globale variablen drin sieht man auch unten in der all.py. Nachdem ich aber herausgefunden habe, dass diese in python lieber nicht verwendet werden sollen habe ich sie getötet (auskommentiert)

Hier der letzte Code der ausgeführt wurde und die Fehlermeldung links rechts und die liste der drei Zahlen in Klammern sind jeweils ausgaben der Unterprogramme seht ihr auch weiter unten.:

Code: Alles auswählen

links
rechts
links
rechts
links
rechts
links
rechts
links
rechts
(238, 187, 202)
Traceback (most recent call last):
  File "main.py", line 22, in <module>
    schlupf = abfrage.schlupf(s)        # hier wird ein jetztbild gemacht und verglichen ob wir wieder am ausgangspunkt sind
  File "/home/pi/test/abfrage.py", line 16, in schlupf
    wert1 = foto.vergleichstart(870,220)#dachpfannelinks wird geprueft
  File "/home/pi/test/foto.py", line 12, in vergleichstart
    bildmachendialog.fin()
  File "/home/pi/test/bildmachendialog.py", line 42, in fin
    camera.capture('startstatus.jpg')
  File "/usr/lib/python2.7/dist-packages/picamera/camera.py", line 1423, in capture
    'Timed out waiting for capture to end')
picamera.exc.PiCameraRuntimeError: Timed out waiting for capture to end

Hier Meine main.py Funktion die alles weitere aufruft die Unterprogramme sind dann drunter aufgelistet

Code: Alles auswählen

import bruten                   #laesst den spieler nach links und rechts laufen
import abfrage                  # hier werden die Abfragen der bilder durchgefuehrt
import bildmachendialog         # hier werden alle bilder macht
import all
#import pokecenter
#import pokebox


platz = 0                       #Wenn alle Plaetze belegt sind "platz = 0", brauchen wir nicht nach neuen Eiern zu fragen
p = 0
schlupf = 0                     #Wenn alle Eier geschluepft sind "schlupf = 5", dann laufen wir zum PC
s = 0
error = 0

while error == 0:

        all.ydruck(1)           # der yknopf wird gedrueckt

        while schlupf < 5:
                bildmachendialog.go() # hier wird ein bild von der ausganssituation gemacht
                bruten.bruten() #5 mal hin und her laufen
                schlupf = abfrage.schlupf(s)    # hier wird ein jetztbild gemacht und verglichen ob wir wieder am ausgangspunkt sind
                s = schlupf                     # falls nicht ist ein Ei geschluepft deshalb wird schlupf hochgezaehlt
                print 'schlupf = ',s

                if platz < 5:
                        platz = abfrage.ei(p)   # abfrage ob wie ein neues Ei bekommen haben.
                        p = platz
                        print 'platz = ',p

                        if platz == -1:
                                error = 1
                                break

        if error == 1:
                break

Hier das Programm bruten.py:

Code: Alles auswählen

import all

def bruten():
        i=5 

        while i!=0:	# er soll also 5 mal hin und her laufen

                all.links(4)

                all.rechts(5)

                i=i-1

Hier das Programm abfrage.py:

Code: Alles auswählen

import foto
import foto2
import time
import all
#import ei
#import bildmachenstart
import bildmachendialog

def schlupf(schlupf):
# hier wird geprueft, ob auf dem Weg etwas geschluepft ist. Das Programm foto.vergleichstart(x,y) bekommt die x und y werte des zu ueberpruefenden pixels uebergeben.
# Innerhalb des programms foto.vergleich wird also ein start bild mit einem jetzt bild verglichen, um zu schauen ob wir wieder am ausgangspunkt beim eiermann sind.
# bekommen wir eine 1 zurueck sind die pixel der beiden bilder identisch, ansonsten bekommen wir eine 0 zurueck.



        wert1 = foto.vergleichstart(870,220)#hier werden die pixelwerte eigentlich ueberprueft
        print 'wert1=',wert1
# wenn wert1 = 1 dann rechts angekommen
        if wert1==1:
                wert2 = foto.vergleichstart(510,600)#hier werden auch die pixel ueberprüft
                print 'wert2=',wert2
# wenn wert2 = 1 dann kein ei geschluepft
                if wert2 == 0:
# geschluepfte eier hochzaehlen und den eierschluepfdialog durchklicken
                        schlupf = schlupf+1
                        all.adruck(0.5)
                        time.sleep(20)
                        all.bdruck(0.5)
                else:
                        schlupf=schlupf
        else:
# geschluepfte eier hochzaehlen und den eierschluepfdialog durchklicken
                schlupf = schlupf +1
                all.adruck(0.5)
                time.sleep(20)
                all.bdruck(0.5)
                all.rechts(5)
# neues ausgangsbild zum vergleichen schieszen
                #bildmachendialog.go()
# geschluepfte eier anzahl wird zurueckgegeben
        return schlupf

#############################################################################################

def ei(platz):
# hier wird nach 5 mal hin und her laufen der eiermann angesprochen. Es wird ein pixel vom weiszen dialog fenster eingelesen
        all.adruck(0.5)
# Kontrollfoto fuer die pixel des weiszen dialogfenster schieszen
        bildmachendialog.los()
# nach 3 weiteren a klicks sollte sich das Dialogfenster schlieszen.
        i=3
        while i>0:
                all.adruck(0.5)
                i=i-1
# hier wird ueberprueft, ob das Dialogfenster weg ist. Ist dies nicht der Fall erhalten wir ein Ei.
        wert4=foto2.vergleichdialog(510,600)#rasenpixel

# bei wert4 gleich 1 haben wir ein Ei
        if wert4 == 1:
# Platz im Team wird hochgezaehlt
                platz=platz+1
                j=3
# Dialog wird fortgesetzt
                while j>0:
                        all.adruck(0.5)
                        j=j-1
                time.sleep(4)
                all.adruck(0.5)
                all.adruck(0.5)
                wert5 = foto2.vergleichdialog(510,600)  #falls noch weisz da, dann error
                if wert5==1:                    # bei 1 gibts einen error programm abbruch in Main
                        platz = -1
        return platz

Hier das Programm bildmachendialog.py:

Code: Alles auswählen

import time
import picamera
#camera = picamera.PiCamera()
#print 'start'
#camera.CAPTURE_TIMEOUT = 60
#picamera.PiCamera.CAPTURE_TIMEOUT = 60
#print camera
def los():
        camera = picamera.PiCamera()

        time.sleep(3)
        camera.capture('dialog.jpg')

        camera.close()


def end():
        camera = picamera.PiCamera()

        time.sleep(3)
        camera.capture('dialogstatus.jpg')

        camera.close()


def go():
        camera = picamera.PiCamera()

        time.sleep(3)
        camera.capture('start.jpg')

        camera.close()

def fin():
        camera = picamera.PiCamera()

        time.sleep(3)
        camera.capture('startstatus.jpg')

        camera.close()

Hier das Programm foto.py welches ein jetzt bild macht und die Pixel werte mit dem Start bild vergleicht:

Code: Alles auswählen

import bildmachendialog
def vergleichstart(x,y):
#RGB werte aus Bilddatei auslesen
        from PIL import Image
        img = Image.open('start.jpg')
        rgb = img.getpixel((x, y))

        b = rgb[-1]
        g = rgb[-2]
        r = rgb[-3]
        print rgb
        bildmachendialog.fin()
        from PIL import Image
        img = Image.open('startstatus.jpg')
        rgb = img.getpixel((x, y))

        b1 = rgb[-1]
        g1 = rgb[-2]
        r1 = rgb[-3]
        print rgb

        rot = r+24
        rot1 = r-24

        gelb = g+24
        gelb1 = g-24

        blau = b+24
        blau1 = b-24

        wert1 = 0

        if (r1 < rot) and (r1 > rot1):
                print 'r'
                if (b1 < blau) and (b1 > blau1):
                        print 'b'
                        if (g1 < gelb) and (g1 > gelb1):
                                print 'g'
                                wert1=1
   	return wert1

Hier das Programm foto2.py ähnlich zu foto.py nur andere Bilddateien:

Code: Alles auswählen

import bildmachendialog
def vergleichdialog(x,y):
#RGB werte aus Bilddatei auslesen
        from PIL import Image
        img = Image.open('dialog.jpg')
        rgb = img.getpixel((x, y))

        b = rgb[-1]
        g = rgb[-2]
        r = rgb[-3]
        print rgb
        bildmachendialog.end()
        from PIL import Image
        img = Image.open('dialogstatus.jpg')
        rgb = img.getpixel((x, y))

        b1 = rgb[-1]
        g1 = rgb[-2]
        r1 = rgb[-3]
        print rgb

        rot = r+24
        rot1 = r-24

        gelb = g+24
        gelb1 = g-24

        blau = b+24
        blau1 = b-24

        wert2 = 0

        if (r1 < rot) and (r1 > rot1):
                if (b1 < blau) and (b1 > blau1):
                        if (g1 < gelb) and (g1 > gelb1):
                                wert2=1

        return wert2

Hier das Programm all.py welches alle Servos mit PWM ansteuert:

Code: Alles auswählen

import time
import RPi.GPIO as gpio


def einsoderzwei(servopin,winkel,dauer):

        # GPIO initialisieren
        gpio.setmode(gpio.BCM)
        gpio.setup(servopin, gpio.OUT)

        # PWM-Frequenz auf 50 Hz setzen
        servo = gpio.PWM(servopin, 50)

        # PWM starten, Servo auf 90 Grad
        time.sleep(0.1)
        servo.start(7.5)
        #servo.ChangeDutyCycle(7.5)
        time.sleep(0.1)

        # Umrechnung Grad in Tastverhaeltnis
        winkel = float(winkel)

        def setservo(winkel):
                if winkel < 0:
                        winkel = 0
                elif winkel > 180:
                        winkel = 180
                pwm = winkel/18 + 2.5
                # print "pwm:",pwm
                servo.ChangeDutyCycle(pwm)


        setservo(winkel)

        time.sleep(dauer)

        servo.ChangeDutyCycle(7.5)

        time.sleep(0.5)

        servo.ChangeDutyCycle(0.0)
        servo.stop()
        gpio.cleanup()


u=0
w=0


def links(dauer):
        #if u == 4:
                # falls knopf schonmal gedruckt soll er kurz einen anderen servo ansprechen; hier servo 19 mit 90 grad
        einsoderzwei(15,90,0)
        print 'links'

        d=dauer

        #einsoderzwei(servopin,winkel,dauer,pause)
        #servopins gibt es: 16,17,18,19
	#servopin 16 = bdruck oder ydruck
        #servopin 17 = unten oder rechts
        #servopin 18 = oben oder links
        #servopin 19 = adruck oder xdruck

        einsoderzwei(18,115,d)
        #global u
        #u=4

def oben(dauer):

        einsoderzwei(15,90,0)
        print 'oben'

        d=dauer
        einsoderzwei(18,41.5,d)
        #global u
        #u=4
def unten(dauer):

        einsoderzwei(15,90,0)
        print 'unten'

        d=dauer
        einsoderzwei(17,38,d)
        #global u
        #u=3

def rechts(dauer):

        einsoderzwei(15,90,0)
        print 'rechts'

        d=dauer
        einsoderzwei(17,145,d)
        #global u
        #u=3


def ydruck(dauer):

        einsoderzwei(15,90,0)
        print 'ydruck'

        d=dauer
        einsoderzwei(16,73,d)
        #global w
        #w=1

def bdruck(dauer):

        einsoderzwei(15,90,0)
        print 'bdruck'

        d=dauer
        einsoderzwei(16,140,d)
        #global w
        #w=1

def adruck(dauer):

        einsoderzwei(15,90,0)
        print 'adruck'

        d=dauer
        einsoderzwei(19,80,d)
        #global w
        #w=2
def xdruck(dauer):

        einsoderzwei(15,90,0)

        print 'xdruck'

        d=dauer
        einsoderzwei(19,163,d)
        #global w
	#w=2

[__deets__]

Die Fehlermeldung, die du zeigst, passt nicht zu deiner Fehlerbeschreibung. Die Meldung besagt, dass die Kamera nicht mehr reagiert.

Es hat sich bei solchen Problemen bewaehrt, die verschiedenen Teile voneinander zu loesen: probier mal dein Programm so umzuschreiben, dass es *ohne* Kamera input auskommt. Einfach zB indem du zufaellige Werte zurueck gibst. Und umgekehrt die Analyse zu machen, ohne die GPIOs anzuwerfen.

Ein Tipp, den ich schon gleich geben kann, der ggf. etwas bringt: vergiss, dass es RPI.GPIO gibt. Das ist ziemlicher Mist. Benutz das deutlich bessere PIGPIO. Das ist ein kleines bisschen Anpassungsarbeit, aber die ist es wert! Und es gibt mit RPI.GPIO gelegentlich solche Probleme wie du sie beschreibst, mit PIGPIO habe ich das noch nicht erlebt.

[hellothere]

Die Fehlermeldung, die du zeigst, passt nicht zu deiner Fehlerbeschreibung. Die Meldung besagt, dass die Kamera nicht mehr reagiert.

Es hat sich bei solchen Problemen bewaehrt, die verschiedenen Teile voneinander zu loesen: probier mal dein Programm so umzuschreiben, dass es *ohne* Kamera input auskommt. Einfach zB indem du zufaellige Werte zurueck gibst. Und umgekehrt die Analyse zu machen, ohne die GPIOs anzuwerfen.

Ein Tipp, den ich schon gleich geben kann, der ggf. etwas bringt: vergiss, dass es RPI.GPIO gibt. Das ist ziemlicher Mist. Benutz das deutlich bessere PIGPIO. Das ist ein kleines bisschen Anpassungsarbeit, aber die ist es wert! Und es gibt mit RPI.GPIO gelegentlich solche Probleme wie du sie beschreibst, mit PIGPIO habe ich das noch nicht erlebt.

Ja da hast du Recht also im Prinzip habe ich dann eigentlich zwei Probleme.

1. führt er nach einer Zeit die Servo Programme aus ohne das die Servos sich bewegen.

2. hängt er sich nach den Servo Programm im Camera Programm auf.

alles klar, werde das ganze einmal von einander trennen und PIGPIO verwenden. Melde mich sobald ich ein paar Versuche gemacht habe. Danke für deine Antwort!

[hellothere]

Die Fehlermeldung, die du zeigst, passt nicht zu deiner Fehlerbeschreibung. Die Meldung besagt, dass die Kamera nicht mehr reagiert.

Es hat sich bei solchen Problemen bewaehrt, die verschiedenen Teile voneinander zu loesen: probier mal dein Programm so umzuschreiben, dass es *ohne* Kamera input auskommt. Einfach zB indem du zufaellige Werte zurueck gibst. Und umgekehrt die Analyse zu machen, ohne die GPIOs anzuwerfen.

Ein Tipp, den ich schon gleich geben kann, der ggf. etwas bringt: vergiss, dass es RPI.GPIO gibt. Das ist ziemlicher Mist. Benutz das deutlich bessere PIGPIO. Das ist ein kleines bisschen Anpassungsarbeit, aber die ist es wert! Und es gibt mit RPI.GPIO gelegentlich solche Probleme wie du sie beschreibst, mit PIGPIO habe ich das noch nicht erlebt.

Hi,

also ich habe das Problem erstmal auf die servo datei eingrenzen können. Danach habe ich mich mit pigpio auseinander gesetzt und dieses so gut es ging eingearbeitet.

Der neue Code(siehe weiter unten) funktioniert wieder eine Weile und steuert die servos an. Dann hört er wieder auf zu arbeiten.

Da ich neu in Python bin habe ich keine Ahnung was threads genau sind und verstehe auch beim googlen nicht wirklich wie ich das vermeiden kann. siehe Fehlermeldung:

Code: Alles auswählen

Traceback (most recent call last):
  File "testensteuerung.py", line 5, in <module>
    steuerung.oben(1)
  File "/home/pi/test/steuerung.py", line 35, in oben
    drucken(18,dauer,1200)
  File "/home/pi/test/steuerung.py", line 13, in drucken
    pi = pigpio.pi()
  File "/usr/lib/python2.7/dist-packages/pigpio.py", line 4942, in __init__
    self._notify = _callback_thread(self.sl, host, port)
  File "/usr/lib/python2.7/dist-packages/pigpio.py", line 1055, in __init__
    self.start()
  File "/usr/lib/python2.7/threading.py", line 745, in start
    _start_new_thread(self.__bootstrap, ())
thread.error: can't start new thread

Mein code sieht jetzt so aus:

Code: Alles auswählen

import pigpio
import time

def drucken(servopin,dauer,pw):

        #import pigpio

        MIN_PW= 1000    #links
        MID_PW= 1500    #stopp
        MAX_PW = 2000 #rechts


        pi = pigpio.pi()

        pulsewidth = MID_PW

        pi.set_servo_pulsewidth(servopin, pulsewidth)
        time.sleep(0.5)

        pulsewidth = pw

        pi.set_servo_pulsewidth(servopin, pulsewidth)

        time.sleep(dauer)

        pi.set_servo_pulsewidth(17, 1500)

        time.sleep(0.5)
#pi.close()

def unten(dauer):

        drucken(17,dauer,900)
def oben(dauer):
        drucken(18,dauer,1200)

die funktionen rufe ich dann über ein anderes programm in einem while loop auf:

Code: Alles auswählen

import steuerung

while True:
        steuerung.unten(1)
        steuerung.oben(1)

[hellothere]

Ah habe meinen fehler gefunden. Es fehlte ein pi.stop() am ende(irgendwie hatte ich pi.close() im Kopf ). Der Code zur korrekten Ansteuerung der Servos mit PWM über pigpio lautet jetzt so:

Code: Alles auswählen

import pigpio
import time

def drucken(servopin,dauer,pw):

        #import pigpio

        MIN_PW= 1000    #links
        MID_PW= 1500    #stopp
        MAX_PW = 2000 #rechts


        pi = pigpio.pi()

        pulsewidth = MID_PW

        pi.set_servo_pulsewidth(servopin, pulsewidth)
        time.sleep(0.5)

        pulsewidth = pw

        pi.set_servo_pulsewidth(servopin, pulsewidth)

        time.sleep(dauer)

        pi.set_servo_pulsewidth(17, 1500)

        time.sleep(0.5)
        pi.stop()

def unten(dauer):

        drucken(17,dauer,900)
def oben(dauer):
        drucken(18,dauer,1200)

Melde mich falls ich weiter fragen habe.

[hellothere]

Hallo,

die PWM mit PIGPIO funktioniert auch nur eine bestimmte Zeit danach hört es wieder auf etwas zu tun. Ziel ist es das ganze über z.b. tage oder wochen laufen zu lassen. Schreibt sich vllt irgendwo ein Speicher voll? Verzweifle langsam . Brauche da echt Hilfe bitte.

die Fehlermeldung folgt. vor dem Programm starte ich jedes mal den Pigpio Daemon mit dem befehl

Code: Alles auswählen

sudo pigpiod

Danach starte ich dann das Programm und es läuft wie gesagt einige Zeit, dann hört es auf... weiß jemand eine Lösung ?

Die FehlerMeldung die beim Abbruch kommt sieht wie folgt aus:

Code: Alles auswählen

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Can't connect to pigpio at localhost(8888)

Do you have permission to access the pigpio daemon?
Perhaps it was started with sudo pigpiod -nlocalhost
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Traceback (most recent call last):
  File "newmain.py", line 36, in <module>
    shiny=shinyabfrage.los()
  File "/home/pi/test/shinyabfrage.py", line 25, in los
    pokecenter.rueckweg()
  File "/home/pi/test/pokecenter.py", line 97, in rueckweg
    steuerung.rechts(2)
  File "/home/pi/test/steuerung.py", line 48, in rechts
    drucken(17,dauer,2200)
  File "/home/pi/test/steuerung.py", line 17, in drucken
    pi.set_servo_pulsewidth(servopin, pulsewidth)
  File "/usr/lib/python2.7/dist-packages/pigpio.py", line 1594, in set_servo_pulsewidth
    self.sl, _PI_CMD_SERVO, user_gpio, int(pulsewidth)))
  File "/usr/lib/python2.7/dist-packages/pigpio.py", line 977, in _pigpio_command
    sl.s.send(struct.pack('IIII', cmd, p1, p2, 0))
AttributeError: 'NoneType' object has no attribute 'send'

das Programm sieht wie folgt aus:

Code: Alles auswählen

import pigpio
import time

def drucken(servopin,dauer,pw):

        #import pigpio

        MIN_PW= 1000    #links
        MID_PW= 1600    #stopp
        MAX_PW = 2000 #rechts


        pi = pigpio.pi()

        pulsewidth = MID_PW

        pi.set_servo_pulsewidth(servopin, pulsewidth)
        time.sleep(0.5)

        pulsewidth = pw

        pi.set_servo_pulsewidth(servopin, pulsewidth)

        time.sleep(dauer)

        pi.set_servo_pulsewidth(servopin, MID_PW)

        time.sleep(0.5)
        pi.stop()

def unten(dauer):

        drucken(17,dauer,950)
        print 'unten'

def oben(dauer):

        drucken(18,dauer,900)
        print 'oben'

[__deets__]

Geht das Programm nach Neustart wieder? Ohne pigpiod starten zu müssen?

[hellothere]

Geht das Programm nach Neustart wieder? Ohne pigpiod starten zu müssen?

Ja das geht dann direkt wieder ohne pigpiod wieder mit

Code: Alles auswählen

sudo pigpiod

starten zu müssen.

hast du eine Idee woran das liegen könnte ? :K

Viele Grüße

[Sirius3]

@hellothere: man müßte genauer eruieren, warum die Verbindung manchmal fehlschlägt. Wie oft wird `drucken` denn aufgerufen? Ist es wohl besser, pi nur einmal zu initialisieren und das mehrmals zu versuchen, bis eine Verbindung zu Stande kommt. Falls Dir das noch niemand gesagt, hat, eingerückt wird immer mit 4 Leerzeichen pro Ebene und Leerzeilen sollten sparsam verwendet werden.

Code: Alles auswählen

import pigpio
import time

MIN_PW= 1000    #links
MID_PW= 1600    #stopp
MAX_PW = 2000 #rechts

pi = pigpio.pi()


def drucken(servopin, dauer, pw):
    pi.set_servo_pulsewidth(servopin, MID_PW)
    time.sleep(0.5)
    pi.set_servo_pulsewidth(servopin, pw)
    time.sleep(dauer)
    pi.set_servo_pulsewidth(servopin, MID_PW)
    time.sleep(0.5)

    
def unten(dauer):
    drucken(17, dauer, 950)
    print 'unten'


def oben(dauer):
    drucken(18, dauer, 900)
    print 'oben'

[hellothere]

@hellothere: man müßte genauer eruieren, warum die Verbindung manchmal fehlschlägt. Wie oft wird `drucken` denn aufgerufen? Ist es wohl besser, pi nur einmal zu initialisieren und das mehrmals zu versuchen, bis eine Verbindung zu Stande kommt. Falls Dir das noch niemand gesagt, hat, eingerückt wird immer mit 4 Leerzeichen pro Ebene und Leerzeilen sollten sparsam verwendet werden.

Code: Alles auswählen

import pigpio
import time

MIN_PW= 1000    #links
MID_PW= 1600    #stopp
MAX_PW = 2000 #rechts

pi = pigpio.pi()


def drucken(servopin, dauer, pw):
    pi.set_servo_pulsewidth(servopin, MID_PW)
    time.sleep(0.5)
    pi.set_servo_pulsewidth(servopin, pw)
    time.sleep(dauer)
    pi.set_servo_pulsewidth(servopin, MID_PW)
    time.sleep(0.5)

    
def unten(dauer):
    drucken(17, dauer, 950)
    print 'unten'


def oben(dauer):
    drucken(18, dauer, 900)
    print 'oben'

hi,

erstmal danke für deine Antwort.

also deine erste Frage war ja wie oft drucken aufgerufen wird:

es wird ziemlich oft aufgerufen, da darüber ja tasten angesprochen werden, um z.b. im spiel selbst nach oben, rechts, links und unten zu laufen.
also im Prinzip bei jeder Richtungsänderung die ich im Spiel ausführen will.
wie gesagt das Programm soll dann z.b. ein paar tage durchweg laufen und dabei wird drucken dann bestimmt über 1000 mal aufgerufen werden.
oder meintest du wie oft es wirklich von der main in einem ablauf aufgerufen wird?

ich werde deine Tipps jetzt erstmal einarbeiten und mich melden, falls das Problem weiterhin besteht.

meine Frage ist warum man lieber mit Leerzeichen einrücken sollte?
also hat das einen python eigenen Grund oder ist das nur wegen der Optik?
ich habe bisher immer mit Tabulator eingerückt.

und warum sind leerzeilen gefährlich?
ich stelle die fragen nicht aus skepsis sondern nur um mein Wissen zu erweitern.

Vielen Dank
ich melde mich

[Sirius3]

@hellothere: mit "wie oft" meinte ich, wie oft pro Sekunde.

Wenn man verschieden Einrückarten mischt, dann kann es zu Problemen kommen, daher ist der Standard, an den sich alle halten (sollten), 4 Leerzeichen pro Ebene und keine Tabs zu verwenden.
Die Leerzeilen sind nur der Lesbarkeit wegen. Wenn ein `def` im leeren Raum steht, dann sieht man einfach nicht, wohin es gehört.