NoneType object is not callable ... Problem

[wafi]

Moin
ich versuche diverse Sensoren für eine Selbsteueranlage auszulesen. Leider kommt bei einem Sensor dauernd die Fehlermeldung: "NoneType object is not callable", wobei das "lustige" ist, die Werte werden dennoch eingelesen. Die Fehlermeldung bezieht sich auf folgenden code in einer Schleife im Modul core-kernel:

Code: Alles auswählen

        try:
            self.read_gps() 
        except Exception as ex:
            self.data.has_gps = False
            logging.exception("CORE:\tError in update loop (GPS) - %s" % ex)


        try:
            self.read_wind()
        except Exception as ex:
            self.data.has_wind = False
            logging.exception("CORE:\tError in update loop (Wind) - %s" % ex)

Die Einlesen der Daten findet hier statt, wieder GPS und Wind dargestellt.

Code: Alles auswählen

    def read_gps(self):
        if self._gps_sensor:
            (lat, lon, heading, speed) = self._gps_sensor.readgps_sensor()
            self.data.gps_lat = float(lat)
            self.data.gps_lon = float(lon)
            self.data.gps_heading = float(heading)
            self.data.gps_speed = float(speed)
            self.data.has_gps = True
        else:
            self.data.has_gps = False

nahezu selbe Syntax für den Wind-Sensor bzw. Wegepunkte aus einem Navigationsprogramm produziert keinen Fehler, als Bleistift Wind-Sensor:

Code: Alles auswählen

    def read_wind(self):
        if self._wind_sensor:
            (Wian, Wspeed) = self._wind_sensor.readwind_sensor()
            self.data.wind_Wian = Wian
            self.data.wind_Wspeed = Wspeed
            if Wian > 180:
                self.data.wind_Wanz = 360 - Wian
            else:
                self.data.wind_Wanz = Wian              
            self.data.has_wind = True
        else:
            self.data.has_wind = False

beide lesen aus einer Datei die NMEA Daten aus:

Code: Alles auswählen

    def readwind_sensor(self):
        data = 0
        data, addr = sock.recvfrom(1024)
        datalist = data.split(',')       
        if datalist[0] == "$WIMWV":     #$WIMWV
            parts_len = len(datalist) - 1
            for index, item in enumerate(datalist):     
                Wian = float(datalist[1])       #1
                Wspeed = float(datalist [3])   #3
                self.oldWian = Wian
                self.oldWspeed = Wspeed
        else:
            Wian = self.oldWian
            Wspeed = self.oldWspeed
        return Wian, Wspeed

    def readgps_sensor(self):
        data = 0
        data, addr = sock.recvfrom(1024)
        datalist = data.split(',')       
        if datalist[0] == "$GPRMC":
            parts_len = len(datalist) - 1
            for index, item in enumerate(datalist):
                lat = float(datalist [3])/100
                lon = float(datalist [5])/100
                heading = float(datalist[8])
                speed = float(datalist [7])
                self.oldlat = lat
                self.oldlon = lon
                self.oldheading = heading
                self.oldspeed = speed
        else:
            lat = self.oldlat
            lon = self.oldlon
            heading = self.oldheading
            speed = self.oldspeed
        return lat, lon, heading, speed

Ich verstehe nicht, wo der Knackpunkt liegt, vielleicht hat jemand dazu eine Idee.

[BlackJack]

@wafi: Also mir ist das zum raten welcher Aufruf den Fehler produziert ein wenig zu viel Code. Welche Zeile ist es denn? Wie sieht der komplette Traceback aus?

[Sirius3]

@wafi: Dein readwind_sensor und readgps_sensor haben jeweils eine unsinnige for-Schleife und noch einige Zuweisungen, die nicht weiter verwendet werden. Ansonsten wäre der komplette Stacktrace der Fehlermeldung noch hilfreich.

[wafi]

Sorry, wird nachgeliefert
Die Fehlermeldung bezieht sich auf Zeile 2 hier = Zeile 98 im Skript
genauer Wortlaut

Core: Error in update loop (GPS) - ´NoneType´ object is not callable
Traceback (most recent call last):
File"/home/pi/autopilot/fishpi/core_kernel.py, line 98, in update
self.read_gps()
TypeError: ´NoneType´ object is not callable

zu den Schleifen, maybe dass es da sinnvollere Lösungen gibt enumerate einzubinden, würde auch nicht behaupten, dass ich viel Ahnung hätte sondern taste mich an Beispielen an eine Lösung ran. Da gibt es sicherlich noch einiges mehr zu meckern in dem gesamten Code. Die Zuweisung zu oldWian etc ist sinnvoll, ansonsten stoppt die Auslesung wenn noch kein neuer Datensatz vorhanden ist oder noch schlimmer, springt auf Null.

[Sirius3]

@wafi: also liegt die Ursache in dem Teil, den Du uns nicht zeigst.
Die Schleifen sind deswegen unsinnig, weil Du weder »item« noch »index« benutzt, die Schleife macht also mindestens 9 mal genau das selbe, und das ist 8 mal zu oft.

[BlackJack]

@wafi: Noch ein paar Anmerkungen:

Beim Logging sollte man die Werte nicht selber in die Zeichenkette formatieren sondern das dem Logging-Rahmenwerk überlassen. Dann passiert das nur wenn überhaupt eine Ausgabe entsteht, und nicht grundsätzlich immer.

Bei `read_gps()` sollte die Funktion die den Sensor tatsächlich ausliest schon Gleitkommawerte liefern. Und siehe da, das tut sie sogar, also ist das erneute Aufrufen von `float()` mit jedem Einzelwert überflüssig.

Bei `readwind_sensor()` ist die Zuweisung von 0 an `data` am Anfang unsinnig. Der Wert wird ganz offensichtlich nicht verwendet.

Wo kommt `sock` her? Ausser Konstanten sollte man in Funktionen und Methoden nichts verwenden was nicht als Argument übergeben wurde.

Falls es sich um eine TCP-Verbindung handelt ist der Code zum empfangen falsch.

Konkrete Typen sollte man nicht in Namen verwenden. `datalist` könnte man beispielsweise `parts` nennen.

`parts_len`, `index`, und `item` werden definiert aber nicht verwendet. Insgesamt ist die Schleife kompletter Unsinn weil da nur mehrfach jedes mal exakt das gleich mit jedes mal dem gleichen Ergebnis gemacht wird.

Ist das nötig immer alle alten Werte einzeln an das Objekt zu binden, statt zum Beispiel ein Tupel mit den Werten zu verwenden?

In `readgps_sensor()` wiederholt sich fast alles von dem Unsinn aus `readwind_sensor()`.

Ungetestet:

Code: Alles auswählen

    def readwind_sensor(self):
        data, _address = self.sock.recvfrom(1024)
        parts = data.split(',')      
        if parts[0] == '$WIMWV':
            self.values = (float(parts[1]), float(parts[3]))
        return self.values

# ...

    def readgps_sensor(self):
        data, _address = self.sock.recvfrom(1024)
        parts = data.split(',')      
        if parts[0] == '$GPRMC':
            self.values = [
                float(parts[i]) / d
                for i, d in [(3, 100), (5, 100), (8, 1), (7, 1)]
            ]
        return self.values

Falls das tatsächlich der komplette Traceback ist, dann hast Du irgendwo im Code `self.read_gps` an den Wert `None` gebunden. Denn genau das sagt die Meldung aus.

[wafi]

Sirius
naja, war halt nen Codeschnipsel zum Auslesen von NMEA Daten, wie schon gesagt, bin da eher newbie.

BlackJack,
nicht TCP-Verbindung sondern UDP

[wafi]

yes Sir BlackJack

ich hab eine Bindung an None gefunden, ist in dem file localconfigpy in der def_ini

Code: Alles auswählen

       
    def __init__(self):
        # TODO setup logging (from config)
        logger = logging.getLogger()
        logger.setLevel(logging.DEBUG)
        console = logging.StreamHandler()
        logger.addHandler(console)
        
        if os.path.exists(self.config_file):
            # TODO read any static config from file
            pass
        
        # create directories
        if not os.path.exists(self._root_dir):
            os.makedirs(self._root_dir)
        if not os.path.exists(self.navigation_data_path):
            os.makedirs(self.navigation_data_path)
        if not os.path.exists(self.imgs_path):
            os.makedirs(self.imgs_path)
        if not os.path.exists(self.logs_path):
            os.makedirs(self.logs_path)

        # add file logging
        log_file_stem = os.path.join(self.logs_path, 'fishpi_%s.log' % time.strftime('%Y%m%d_%H%M%S'))
        handler = logging.handlers.RotatingFileHandler(log_file_stem, backupCount=50)
        formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        # can force new file start if needed
        #handler.doRollover()
        
        # default attachments to None
        self.gps_sensor = None
        self.compass_sensor = None
       # self.temperature_sensor = None
        self.drive_controller = None
       # self.camera_controller = None
        self.udp_sensor = None
        self.ruder_sensor = None
        self.tasten_sensor = None
        self.wind_sensor = None
        
        # load vehicle constants
        self._vehicle_constants = VehicleConstants()
    
        # RPC config
        self._server_name = None
        self._rpc_port = None
       # self._camera_port = None
                
        # TODO any other init
        pass

ist allerdings die einzige Bindung und was mich wundert, selbe Bindung existiert für die anderen Sensoren ohne selbige Fehlermeldung.

Werde deinen Vorschlag ausprobieren. Vielen Dank erstmal dafür.

@Sirius
habe übrigends absolut kein Problem den gesamten Code bereit zu stellen, macht m.E. zur Zeit noch keinen Sinn.

[Sirius3]

@wafi: in dem gezeigten Code kommt »read_gps« gar nicht vor...

[wafi]

Sirius3

ist mir schon klar, ist aber die einzige Verknüpfung gps mit None, ansonsten kommt read_gps nur in der gezeigten Zeile 98 (bzw2) bzw in der def dazu vor, sonst nirgends und ich bin alle Dateien, die mit dem ganzen Kram zusammen hängen durchgegangen. Nichts, nada, nothing.
In den englischsprachigen Seiten wird das Problem mit dieser Fehlermeldung diversemale diskutiert, nur da programmieren für mich noch nen chinesischer Dialekt ist, macht chinesischer Dialekt auf Englisch, noch nen bißchen weniger Sinn .... grummel

[Sirius3]

@wafi: dass irgendwo explizit »read_gps = None« steht, wäre auch komisch. Wenn ich so einen Fehler hätte, würde ich zeitlich bis zu der Programmversion zurückgehen, bei der der Fehler noch nicht auftritt und mir dann anschauen, was ich seither geändert habe. Idealer weise wären das nur sehr wenige Stellen, wenn der Fehler sich schnell gezeigt hat. Andere Möglichkeit wäre es, im Debugger das Programm schrittweise durchzugehen, um zu sehen, wann »read_gps« seinen Wert ändert, erst in groben Schritten, dann in immer feineren. Statt Debugger kannst Du auch »print«s an strategisch günstigen Stellen platzieren.

[wafi]

Moin again

Sirius3, das mit dem Debugger war ne klasse Idee. Jetzt kann ich etwas konkreter sagen, wo eigentlich ein Fehler passiert, allerdings keine Ahnung, wie man den vermeidet.

Wie gezeigt verweist der Aufruf, der den Fehler produzierte auf folgendes:

Code: Alles auswählen

.....
   @property
    #def last_img(self):
     #   return self._camera_controller.last_img
        
    # Sensors
      
    def read_gps(self):
        if self._gps_sensor:
            (lat, lon, heading, speed) = self._gps_sensor.readgps_sensor()
            self.data.gps_lat = float(lat)
            self.data.gps_lon = float(lon)
            self.data.gps_heading = float(heading)
            self.data.gps_speed = float(speed)
            self.data.has_gps = True
        else:
            self.data.has_gps = False

    def read_compass(self):
        if self._compass_sensor:
            (heading, pitch, roll) = self._compass_sensor.read_sensor()
            self.data.compass_heading = float(heading)
            self.data.compass_pitch = float(pitch)
            self.data.compass_roll = float(roll)
            self.data.has_compass = True
        else:
            self.data.has_compass = False
.......

beim Debuggen dieses Modules ist mir aufgefallen, dass der Zeiger auf @property geht und als nächsten Haltepunkt def read_compass(self) hat. Dachte, ist ja man merkwürdig, weil def read_gps(self) übersprungen wird, also habe ich ... weil ich dachte, vielleicht bin ich zu blind die Abstände richtig einzuhalten oder sowas, den code von def read_gps(self) nochmal geschrieben, diesmal aber unter dem def read_compass(self). Soweit so schick, jetzt kommt die Fehlermeldung ´NoneType`... nicht mehr bei def read_gps(self) sondern bei read_compass(self).
Danach habe ich mehrfach die Positionen der einzelnen Abfragen gewechselt, Resultat, immer die erste Abfrage hinter dem @property wird ignoriert bzw produziert die Fehlermeldung ´NoneType`..., also steckt irgendwie der Wurm in der Syntax mit @property, ohne dass ich dahinter komme was denn daran falsch ist (der Debugger verweißt ja auch auf property)

@BlackJack
habe deinen Vorschlag mal ausprobiert, weil sieht deutlich intelligenter aus, als das was ich da zusammen gezimmert habe. Funktioniert leider nicht so wirklich. Erstmal passiert das, was ich auf jedenfall verhindern wollte, ist kein neuer NMEA Satz da, dann springt die Auswertung auf Null. Gut, das wäre möglich mit oldvalue und else zu lösen, analog zu dem was ich gebastelt hatte. Was ein bißchen merkwürdig ist, für eine gewisse Zeit, schätze mal 5 Min, läuft dein Vorschlag gut, dann verhaspelt sich die Sache aber, was entweder zu wilden Zahlen führt oder aber nur noch die Auslesung eines NMEA Satzes. Die Sätze kommen übrigends sehr unterschiedlich, so gibt die Windanzeige nur etwas aus, wenn sich am Wind etwas ändert. Ist aber erstmal ein zweitrangiges Problem, evt sinnvoller ist es die drei Datensätze auf 3 Adressen zu verteilen. Hatte ich auch schon, bzw. zunächst war es so geplant, GPS via ttyUSB0, Wind via ttyUSB1, Wegepunkt Daten via UDP. Klappte nicht wirklich, denn einmal konnte sich der Raspberry nicht entscheiden, wer nun an ttyUSB0/1 hing zum Zweiten schien Python es nicht zu mögen zwei serielle Schnittstellen auszulesen. Opencpn als Navigationssoftware hatte damit kein Problem und auch keines UDP Daten zu Verfügung zu stellen, deshalb das Tricksen über die Hintertür. Allerdings mocht Opencpn es nicht zwei UDP Adressen zu versorgen und quittierte dies mit einem Komplettabsturz ...

Aber der Reihe nach ... was kann an dem Ding hinter @property falsch sein?

[BlackJack]

@wafi: Du machst `read_gps` von einer Methode zu einem Property, dadurch das Du nur den Code auskommentiert hast auf den sich der ``@property``-Dekorator vorher bezogen hat.

Dadurch wird alleine durch den Zugriff auf das `read_gps`-Attribut schon die Methode ausgeführt. Und die gibt nichts zurück, das heisst implizit gibt die `None` zurück weil jede Funktion oder Methode etwas zurückgeben muss. Und dieses `None` versuchst Du dann aufzurufen. Lösung: Das ``@property`` auch auskommentieren, wenn Du den Code auf den das eigentlich angewendet werden sollte auskommentierst.

[wafi]

Grummel .... auweia, manchmal ist man ja selten blöd ....

alles klar jetzt .... das @property bezog sich auf eine Kamera die in der Ursprungsversion auf einem Modellboot was über den Atlantik fahren sollte, montiert war. Da ich den Code aber für eine Selbsteueranlage mißbrauche, hab ich die Kamerageschichte und einiges andere rausgeschmissen und dabei dann den Bock selber geschossen ... Eine # vor property und es läuft wie es soll

Vielen Dank für deine/eure Geduld

[wafi]

Möchte euch nochmal um Hilfe bitten. Theoretisch klappt jetzt alles, bis auf die Kleinigkeit, dass der Steuermotor nicht angesprochen wird. Ich erhalte folgende Fehlermeldung:

Traceback (most recent call last):
File "/home/pi/autopilot/fishpi/core_kernel.py", line 140, in update
self._navigation_unit.update()
File "/home/pi/autopilot/fishpi/control/navigation.py", line 74, in update
self._drive_controller.set_ruder(observed_ruder)
File "/home/pi/autopilot/fishpi/vehicle/drive_controller.py", line 100, in set_ruder
self.set_PWMpercent(0, percent)
TypeError: set_PWMpercent() takes exactly 2 arguments (3 given)

Code: Alles auswählen

import time
import logging
import smbus
import math
from Adafruit_I2C import Adafruit_I2C



#pwm = PWM()

BUSNR   = 1      # I2C-Bus-Nummer
ADDR    = 0x24   # MCP23017 I2C-Adresse
IODIRA  = 0x00   # Register fuer I/O-Datenflussrichtung Port A
GPIOA   = 0x12   # Register fuer I/O Manipulation von Port A
WUERFEL = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0xc0, 0x00, 0x0c, 0x07, 0x80] # Wuerfel-Muster
i2cBus = smbus.SMBus(BUSNR) # I2C-Objekt instanziieren
i2cBus.write_byte_data(ADDR, IODIRA, 0x00)

class DriveController:
    """ Provides drive and steering control abstraction from eg PWM servo or ESC devices. """

#    BUSNR   = 1      # I2C-Bus-Nummer
#    ADDR    = 0x24   # MCP23017 I2C-Adresse
#    IODIRA  = 0x00   # Register fuer I/O-Datenflussrichtung Port A
#    GPIOA   = 0x12   # Register fuer I/O Manipulation von Port A
#    WUERFEL = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0xc0, 0x00, 0x0c, 0x07, 0x80] # Wuerfel-Muster
#    i2cBus = smbus.SMBus(BUSNR) # I2C-Objekt instanziieren
#    i2cBus.write_byte_data(ADDR, IODIRA, 0x00)
    



    def set_acc(self, acc_level):
        logging.debug("DRIVE:\tacc set to: %s" % acc_level)
        if acc_level < 1.1:
            self.Rudmax = 7
            self.percent = 20
        elif acc_level > 1.1 and acc_level < 1.3:
            self.Rudmax = 10
            self.percent = 30
        elif acc_level > 1.3 and acc_level < 1.5:
            self.Rudmax = 10
            self.percent = 50 
        elif acc_level > 1.5 and acc_level < 1.8:
            self.Rudmax = 15
            self.percent = 70 
        elif acc_level > 1.8:
            self.Rudmax = 15
            self.percent = 100

        
        #self.percent = int(round(40.95 * self.percent))
                          
    def set_steering(self, angle):
        """ Set steering to angle between FULL_LEFT and FULL_RIGHT.
            Input expected as between (-Pi/2) and (Pi/2) and is in radians.
            Negative steering is to port (left) and positive to starboard (right).
            """
        logging.debug("DRIVE:\tSteering set to: %s" % angle)
        angle = angle * 30
            
        self.ruderw = angle
        #logging.debug("DRIVE:\tSetting percent length to :%f for steering angle %f", percent, angle)

    def set_ruder(self, ruder_Winkel):

        percent = self.percent
                          
        if self.ruderw < -1:
            #self.set_SLEEPMode(.05)
            i2cBus.write_byte_data(ADDR, IODIRA, WUERFEL[8])
            i2cBus.write_byte_data(ADDR, GPIOA, WUERFEL[0])
            #self.set_RESTART(self)
            self.set_PWMpercent(0, percent)
            
        elif self.ruderw > 1:
            #self.set_SLEEPMode(.05)
            i2cBus.write_byte_data(ADDR, IODIRA, WUERFEL[8])
            i2cBus.write_byte_data(ADDR, GPIOA, WUERFEL[1])
            #self.set_RESTART(self)
            self.set_PWMpercent(0, percent)         
        else:
            i2cBus.write_byte_data(ADDR, IODIRA, WUERFEL[8])

        
       
    def halt(self):
        """ Halt the drive. """
        i2cBus.write_byte_data(ADDR, IODIRA, WUERFEL[8])
        self.set_SLEEPMode()


    def set_SLEEPMode(self):
        """ Standard servo would be in range 1ms <- 1.5ms -> 2.0ms """
        pass

   # def set_RESTART(self):
   #     """ Standard servo would be in range 1ms <- 1.5ms -> 2.0ms """
   #     pass

    def set_PWMpercent(channel, part):
        """ Standard servo would be in range 1ms <- 1.5ms -> 2.0ms """
        pass
        

class AdafruitDriveController(DriveController):
    """ Provides drive and steering control abstraction from eg PWM servo or ESC devices. """
    

    # TODO might need tuning or configuring
    #servoMin = 150  # Min pulse length out of 4096
    #servoMax = 600  # Max pulse length out of 4096
    
    # 'standard' analog servo freq
    ic_pwm_freq = 400

    def __init__(self, i2c_addr=0x40, i2c_bus=None, debug=False):
        self.debug = debug
        part = 0
        channel = 0
        # Initialise the PWM device
        from Adafruit_PWM_Servo_Driver import PWM
        self._pwm = PWM(i2c_addr, i2c_bus=i2c_bus, debug=debug)
        self._pwm.setPWMFreq(self.ic_pwm_freq)


    def set_SLEEPMode(self):
        self._pwm.setSLEEPMode(self)
 
        
    def set_RESTART(self):
        self._pwm.setRESTART(self)


    def set_PWMpercent(channel, part):
        channel = 0
        self._pwm.setPWMpercent(channel, self.percent)

Ich finde einfach den Fehler nicht, trotz diverser Umformulierungen

[pillmuncher]

set_PWMpercent() ist eine Methode. Deswegen bekommt sie als ersten Parameter automatisch das Objekt übergeben, auf dem die Methode aufgerufen wurde. Normalerweise heißt dieser Parameter - per Konvention - self. Bei dir heißt er channel. Du solltest ein "self, " davor stellen (in beiden Klassen, wo die so heißenden Methoden definiert werden), dann sollte alles funktionieren.

[wafi]

jau, hatte ich auch schon mal so gemacht, klappt aber nicht, Fehlermeldung dann:

Traceback (most recent call last):
File "/home/pi/autopilot/fishpi/core_kernel.py", line 140, in update
self._navigation_unit.update()
File "/home/pi/autopilot/fishpi/control/navigation.py", line 74, in update
self._drive_controller.set_ruder(observed_ruder)
File "/home/pi/autopilot/fishpi/vehicle/drive_controller.py", line 100, in set_ruder
self.set_PWMpercent(0, self.percent)
File "/home/pi/autopilot/fishpi/vehicle/drive_controller.py", line 156, in set_PWMpercent
self._pwm.setPWMpercent(self, channel, self.percent)
TypeError: setPWMpercent() takes exactly 3 arguments (4 given)

wobei ich überhaupt nicht die Aussage verstehe, setPWMpercent nimmt 3 Argumente, aber es sind 4 gegeben .... Wieso sind 4 gegeben, ich habe channel = 0 und die PWM in % nebst dem self, sind nach meiner Meinung 3 Argumente. Ist mir schon öfters passiert und irgendwie durch rumgewurstel dann abgestellt, ohne, dass ich bislang begriffen hätte, was die Fehlermeldung real bedeutet.

[wafi]

btw, der eigentliche Treiber funktioniert, mit folgendem Testprogramm läßt sich das PWM Signal auf den Motor übertragen, hier ein kurzer Ausschnitt:

Code: Alles auswählen

from Adafruit_PWM_Servo_Driver import PWM
import time

pwm = PWM()

while (True):
    print '5'
    pwm.setPWMpercent(0, 5)
    time.sleep(2)
    print '10'
    pwm.setPWMpercent(0, 10)

[BlackJack]

@wafi: Du darfst das erste Argument nicht beim Aufruf übergeben, das wird dort „automagisch” übergeben.

[pillmuncher]

Dein Code:

Code: Alles auswählen

        def set_PWMpercent(channel, part):
            channel = 0
            self._pwm.setPWMpercent(channel, self.percent)

Statt dessen sollte es vermutlich heißen:

Code: Alles auswählen

        def set_PWMpercent(self, channel, part):  # <-- self als ersten Parameter einfügen
            channel = 0  # nbb.: warum wird das auf 0 gesetzt, wenn es doch übergeben wird?
            self._pwm.setPWMpercent(channel, self.percent)

Aus der Fehlermeldung geht hervor, dass dort inzwischen wohl das hier steht (und es um knapp 20 Zeilen nach unten gerutscht ist):

Code: Alles auswählen

self._pwm.setPWMpercent(self, channel, self.percent)

Vermutlich müsste das heißen:

Code: Alles auswählen

self._pwm.setPWMpercent(channel, self.percent)  # <-- hier kein self als erstes Argument