GPIO Ansteuerung eines RaspberryPi mit Multithreading in Python

[ManuH (Gast)]

Momentan versuche ich zwei Schrittmotoren über einen RaspberryPi 
anzusteuern. Die Steuerung habe ich in Python geschrieben und um die 
Geschwindigkeit der beiden Motoren seperat und Zeitgleich steuern zu 
können möchte ich die Funktionen zur Steuerung in zwei Threads laufen 
lassen.

Wenn ich versuche meinen Code auszuführen bekomme ich immer die 
Error-Meldung : Please set pin numbering mode using 
GPIO.setmode(GPIO.BOARD) or GPIO.setmode(GPIO.BCM). Sie tritt auf wenn 
ich von der main in die Threads springe.

Ich habe GPIO.setmode(GPIO.BCM) direkt nach den imports implementiert, 
allerdings vermute ich dass ich meinen Threads diesen "parameter" beim 
aufruf irgendwie mitgeben muss damit er auf die GPIO's zugreifen kann.

t1=Thread(target=MotorSteuerung1,args(iMotorSchritteWeg,iDelay,iDrehrich 
tung)
t2=Thread(target=MotorSteuerung2, 
args=(iMotorSchritteWeg,iDelay,(iDrehrichtung+1)))

t1.start()
t2.start()

So sieht momentan mein Aufruf der Threads aus.

def MotorSteuerung1(MotorSchritteWeg, iDelay, Drehrichtung):
     GPIO.setup(8, GPIO.OUT)
     GPIO.setup(10, GPIO.OUT)

so der Anfang meiner Aufgerufenen Funktion.

Der GPIO.setup aufruf ist auch der most recent call vor der 
Error-Meldung.


Ich bedanke mich für die Hilfe bereits im Vorraus.

Mit vielen Grußen

Manuel

[H. E. (hobby_elektroniker)]

Wie gehst du dabei vor? Sieht mir fast so aus, als wäre die Umsetzung 
oder das Verständnis von Multithreads ein anderes.

Hast du schon sowas in der Richtung versucht? Dabei entstehen wirklich 
unterschiedliche Prozesse die autark arbeiten.

#!/usr/bin/python

import RPi.GPIO as GPIO
from time import sleep
import time
import sys
usleep = lambda x: time.sleep(x/1000.0)
import signal
import json
from StringIO import StringIO
import thread

# create threads
try:
   thread.start_new_thread( launch_switches, () )
   thread.start_new_thread( launch_nfc_tags, () )
   thread.start_new_thread( launch_your_own_method, () )
  
except Exception, e:
   print "Error: unable to start thread" + str(e)

while 1:
   sleep(1)
   pass

[ManuH (Gast)]

Vielen dank für die schnelle Antwort.

Das öffnen meiner Threads ist nicht das problem ich habe getestet ob 
beide laufen und es Funktioniert. Mein problem tritt erst auf sobald ich 
versuche die GPIO Ports für meinen Raspberry zu initialisieren.

Dann kommt die Fehlermeldung wie oben beschrieben dass ich 
GPIO.setmode(BCM) verwenden soll. Allerdings habe ich dies schon an 
jeder erdenklichen Stelle versucht, direkt hinter den Imports, vor dem 
Thread aufruf oder auch in der Funktion welche der Thread aufruft 
selbst.

Mit vielen Grüßen

Manuel

[H. E. (hobby_elektroniker)]

Oh, ich habe etwas total überlesen vor lauter Multithread...

Hast deine Fehlermeldung schon mal genauer angeschaut? ;)

Please set pin numbering mode using
GPIO.setmode(GPIO.BOARD) or GPIO.setmode(GPIO.BCM)

[ManuH (Gast)]

Thread 1 opened
Thread 2 opened
Exception in thread Thread-2:
Traceback (most recent call last):
  File "/usr/lib/python2.7/threading.py", line 810, in __bootstrap_inner
    self.run()
  File "/usr/lib/python2.7/threading.py", line 763, in run
    self.__target(*self.__args, **self.__kwargs)
  File "./Motorsteuerung_VS.py", line 156, in MotorSteuerung2
    GPIO.setup(16, GPIO.OUT)
RuntimeError: Please set pin numbering mode using 
GPIO.setmode(GPIO.BOARD) or GPIO.setmode(GPIO.BCM)

Dies ist die genaue Fehlermeldung. Meine Imports sehen wiefolgt aus:

#!/usr/bin/python
# -*- coding: latin-1 -*-
import os, sys
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
import time
from threading import Thread

Ich habe auch schon versucht es direkt in die Funkiton Motorsteuerung 
welche vom Thread aufgerufen wird zu schreiben ganz am Anfang, die 
Fehlermeldung hat sich allerdings nicht verändert.

Mit vielen Grüßen

Manuel

[H. E. (hobby_elektroniker)]

Dein Problem ist, dass irgendwo vom ersten Byte bis dahin versucht wird, 
zwei unterschiedliche Modi zu benutzen.

GPIO.setmode(GPIO.BOARD) or GPIO.setmode(GPIO.BCM)

Das heißt, irgendwo wird einmal BCM und woanders BOARD benutzt. Das kann 
auch daher kommen, wenn du andere Scripte einbindest, die das setzen. Du 
solltest das zuerst prüfen.

Ggf. hilft es schon, dass du einfach BOARD benutzen. Allerdings musst 
du dann auch deine Script ggf. anpassen um sicherzustellen dein Raspi 
nicht zu beschädigen.

Ich bin mir nicht sicher, wie sich das verhält, wenn andere Scripte im 
Hintergrund laufen, die GPIO aktiv benutzen und einen anderen Modi 
gesetzt haben.

[ManuH (Gast)]

Ich habe es mit GPIO.BOARD versucht und es hat zur selben Fehlermeldung 
geführt. Außerdem habe ich es komplett gelöscht um zu sehen ob sich die 
Fehlermeldung verändert, aber selbst wenn ich überhaupt keinen setmode 
verwende bleibt die Fehlermeldung gleich.

Vielleicht erkennt der geöffnete Thread einfach nicht dass es gesetzt 
wurde bzw. vielleicht muss ich ihm im Threadaufruf etwas mitgeben zur 
GPIO konfiguration.

Mit vielen Grüßen

Manuel

[H. E. (hobby_elektroniker)]

Du könnetest mal noch GPIO.cleanup() versuchen.

Der Fehler ist aber, dass zwei Modi gesetzt werden sollen.

Nochmal: Du solltest alle involvierte Scripte genau überprüfen ob und 
was gesetzt wird.

Anderenfalls musst du zunächst einen anderen Weg einschlagen und 
systematisch vorgehen:

- Bastel dir ein Script, dass eine LED zum leuchten bringt.
- Versuche es in beide Modi und finde heraus, ob das zu Problemen führt.
- Wenn alles klappt, lagere es in ein Thread aus mit so wenig Script und 
Imports wie möglich

Ein kompletter Quellcode sollte ggf. mehr nützen als zu spekulieren.

Grüße

[ManuH (Gast)]

#!/usr/bin/python
# -*- coding: latin-1 -*-
import os, sys
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
import time
from threading import Thread


def main ():
  
    pi = 3.14
    fGeschwindigkeit = 0
    iWeg = 0
    fStreckePMS = 0
    iDrehrichtung = 0
    xRichtigeEingabe = 1
    iDemoAuswahl = 0
    checker = 0
    counter = 0

    try :
        iQuickStart = int(input(("Herzlich willkommen, wollen sie einen Quickstart machen? 1 fuer Ja 2 fuer nein.")))

        if iQuickStart == 2:
            iProgrammAuswahl = int(input("Herzlich willkommen zur Motorsteuerung. \nMoechten Sie den Motor manuell steuern oder ein Demo-Programm starten? (1 = manuelle Steuerung ; 2 = Demo - Programm): \n"))

            if iProgrammAuswahl == 2:
                iDemoAuswahl = int(input("Ihnen stehen 3 verschiede Demo-Programme zur Auswahl:\n1.Vorwaerts/Rueckwarts fahrt\n2.Kurvenfahrt\n3.Dauerbetrieb: \n"))

                # Einlesen der Schrittweite des Schrittmotors (z.B. 1,8)
                fSchrittweite = float(input("Bitte geben Sie die Schrittweite Ihres Schrittmotors ein: \n"))
                # Einlesen der Geschwindigkeit die der Motor fahren sollen

                print(fSchrittweite)
                while xRichtigeEingabe == 1:
                    fGeschwindigkeit = float(input("Bitte geben Sie die Geschwindigkeit des Motors an (sie darf maximal 0.5 m/s betragen): \n"))
            # Falls Geschwindigkeit zu hoch wird der Wert erneut abegefragt
                    if fGeschwindigkeit > 0.5:

                        print("Die maximale Geschwindigkeit beträgt 0.5 m/s.\n")

                    else:
                        xRichtigeEingabe = 0

            # Einlesen des Radius des Reifens den der Schrittmotor antreibt

            iReifenRadius = int(input("Bitte geben Sie den Radius der Reifen des Fahrzeuges an (halber Durchmesser): \n"))

            # Einlesen der Strecke die das Fahrzeug zurücklegen soll

            if iDemoAuswahl != 3:
                iWeg = int(input("Bitte geben sie an wie Weit der Motor fahren soll: \n"))

            # Eingabe der Drehrichtung des Motors

            if iProgrammAuswahl == 1:
                iDrehrichtung = int(input("Bitte geben sie die Drehrichtung des Motors ein ( 1 = Vorwaerts, 2 = Rueckwerts) : "))

            # Startaufforderung

            cStart = input("Moechten Sie den Motor jetzt starten? 1 fuer Start 2 fuer Abbruch: \n")
            print("Vielen dank!\n")

            print("Bruuummmmmm")

        else :
            print("Let's go!")
            iProgrammAuswahl = 2
            iDemoAuswahl = 3
            fSchrittweite = 1.8
            fGeschwindigkeit = 0.5
            iReifenRadius = 75
            iDrehrichtung = 1
            iWeg = 10





        def GeschwindigkeitDelayBerechnung(fSchrittweite, fStreckePMS, fGeschwindigkeit):
            PausenZeitFloat = (1.0 / (fGeschwindigkeit / fStreckePMS) * 1000.0)
            Pause = round(PausenZeitFloat)
            return Pause


        def StreckePMS(fSchrittweite, iReifenRadius):
            StreckePMS = 0
            StreckePMS = ((2.0 * pi * (iReifenRadius / 1000.0)) / (360.0 / fSchrittweite))
            return StreckePMS


        def WegSchrittBerechnung(fSchrittweite, fStreckePMS, iReifenRadius, iWeg):
            MotorSchritte = iWeg / fStreckePMS
            return MotorSchritte


        def round(x):
            if (x > 0):
                x = x + 0.5
                ausgabe = 0
                ausgabe = x
                return ausgabe

            return (int)(x - 0.5)


        def MotorSteuerung1(MotorSchritteWeg, iDelay, Drehrichtung):
            # Die GPIO-PINs des RaspberryPi müssen vor der Verwendung Deklariert werden (Input/Output)
            
            print("Thread 1 opened")

            i = 0
            #GPIO.setup(16, GPIO.OUT)
            # GPIO.setup(10, GPIO.OUT)
            # GPIO.setup(11, GPIO.OUT)
            GPIO.setup(8, GPIO.OUT)
            GPIO.setup(10, GPIO.OUT)
            checker = 0
            counter = 0
            
            while checker == 0 :

                counter = counter + 1
                if counter == MotorSchritteWeg:
                    checker = 1
                if Drehrichtung == 1:
                    # GPIO 15 bestimmt die Drehrichtung des Schrittmotors ( 1 = Vorwärts; 2 = Rückwärts)
                    # GPIO.output(16, GPIO.HIGH)


                    GPIO.output(10, GPIO.HIGH)
                    time.sleep((iDelay/1000))
                    GPIO.output(10, GPIO.LOW)
                    print("1")

                if (Drehrichtung == 2):
                    # GPIO.output(16, GPIO.LOW)

                    GPIO.output(10, GPIO.HIGH)
                    time.sleep((iDelay / 1000))
                    GPIO.output(10, GPIO.LOW)
                    print("2")


        def MotorSteuerung2(MotorSchritteWeg, iDelay, Drehrichtung):
            # Die GPIO-PINs des RaspberryPi müssen vor der Verwendung Deklariert werden (Input/Output)

            print("Thread 2 opened")
            i = 0
            # GPIO.setup(16, GPIO.OUT)
            # GPIO.setup(10, GPIO.OUT)
            # GPIO.setup(11, GPIO.OUT)
            GPIO.setup(16, GPIO.OUT)
            GPIO.setup(18, GPIO.OUT)
            checker = 0
            counter = 0
            print("Came here")
            while checker == 0 :

                counter = counter + 1
                if counter == MotorSchritteWeg:
                    checker = 1
                if Drehrichtung == 1:
                    # GPIO 15 bestimmt die Drehrichtung des Schrittmotors ( 1 = Vorwärts; 2 = Rückwärts)
                    # GPIO.output(16, GPIO.HIGH)


                    GPIO.output(16, GPIO.HIGH)
                    time.sleep((iDelay/1000))
                    GPIO.output(16, GPIO.LOW)
                    print("1")

                if (Drehrichtung == 2):
                    # GPIO.output(16, GPIO.LOW)

                    GPIO.output(16, GPIO.HIGH)
                    time.sleep((iDelay / 1000))
                    GPIO.output(16, GPIO.LOW)
                    print("2")


        def Dauerbetrieb() : 

            #GPIO.setup(4, OUTPUT)
            
            GPIO.setup(16, OUTPUT)
            GPIO.setup(8, OUTPUT)
            GPIO.setup(10, OUTPUT)

          #GPIO 4 ist der ENABLE eingang am Motortreiber
            GPIO.output(16,HIGH)

          #Zugriff auf die Delayzeit die im struct übergeben wurde
            while 1 :
                GPIO.output(16, HIGH)
                counter += counter 
                delay(delays)
                GPIO.output(16, LOW)


        fStreckePMS = StreckePMS(fSchrittweite, iReifenRadius)

        iDelay = GeschwindigkeitDelayBerechnung(fSchrittweite, fStreckePMS, fGeschwindigkeit)

        iMotorSchritteWeg = WegSchrittBerechnung(fSchrittweite, fStreckePMS, iReifenRadius, iWeg)

        print(iDelay)
        print(fStreckePMS)
        print(iMotorSchritteWeg)


        if iProgrammAuswahl == 1:
            t1 = Thread(target=MotorSteuerung, args=(iMotorSchritteWeg,iDelay,iDrehrichtung))
            t2 = Thread(target=MotorSteuerung, args=(iMotorSchritteWeg,iDelay,(iDrehrichtung+1)))
            t1.start()
            t2.start()
            
        elif iDemoAuswahl == 3 :

            t1 = Thread(target=MotorSteuerung1, args=(iMotorSchritteWeg,iDelay,iDrehrichtung))
            t2 = Thread(target=MotorSteuerung2, args=(iMotorSchritteWeg,iDelay,(iDrehrichtung+1)))

            t1.start()
            t2.start()

    except KeyboardInterrupt :
        print("Bye!")
    finally:
        GPIO.cleanup()

main()

Ich werde dem Vorschlag folgen und in einem extra Programm versuchen 
mich an das Problem anzunäheren. Oberhalb habe ich noch einen Prototypen 
von meinem Source-Code angehängt vielleicht fällt Ihnen da noch etwas 
auf. Vielen Dank für Ihre Hilfe.

Mit vielen Grüßen

Manuel

[H. E. (hobby_elektroniker)]

Was erhälst du denn, wenn du print GPIO.getmode() ausliest? Kann das 
nicht leider testen, da ich momentan keinen RaspPi in der Nähe habe.

Kriegst du den Fehler erst, wenn ein Thread gestartet wird oder schon 
zuvor?

[ManuH (Gast)]

Den Fehler bekomme ich erst im Thread sobald ich zum ersten mal versuche 
auf eine GPIO. Funktion zuzugreifen.
print (GPIO.getmode()) hat mir eine 10 auf der Konsole ausgegeben.

Gruß
Manuel

[H. E. (hobby_elektroniker)]

Gibt es denn neue Erkenntnisse?

[Lothar (Gast)]

RISC OS pico und BASIC wäre eine gute Alternative zu Python und 
Multithreading

[ManuH (Gast)]

Das Problem hat sich jetzt durch ändern der verwendeten GPIO-Pins 
erledigt, mir ist allerdings nicht ganz bewusst warum weil die zuvor 
verwendeten auch funktionieren müssten. Vielleicht liegt in diesem Fall 
an den entsprechenden Pins einfach ein Hardware defekt vor.

Gruß Manuel

[H. E. (hobby_elektroniker)]

ManuH schrieb:
> Das Problem hat sich jetzt durch ändern der verwendeten GPIO-Pins
> erledigt, mir ist allerdings nicht ganz bewusst warum weil die zuvor
> verwendeten auch funktionieren müssten. Vielleicht liegt in diesem Fall
> an den entsprechenden Pins einfach ein Hardware defekt vor.
>
> Gruß Manuel

Das würde u.U. bedeuten, dass der PI kaputt ist? Die Frage bleibt, ob du 
ohne Threads damit Input/Output steuern kannst. Z.b. eine LED.

Grüße