Code in Python Klasse packen

[O. A. (sokrates1989)]

Hallo,

ich habe einen Code in Python welcher einen Stepp-motor antsteuert.

Wie kann ich diesen nun in eine Klasse packen?

Ich habe nur ganz grundlegende Python Kenntnisse..wäre das sehr 
aufwending?

Gruß

import machine
import time 

# Definition der Pinbelegung

d1 = machine.Pin(19, machine.Pin.OUT) 
d2 = machine.Pin(18, machine.Pin.OUT) 
d3 = machine.Pin(17, machine.Pin.OUT) 
d4 = machine.Pin(16, machine.Pin.OUT) 


class Stepper():
  

  def move(direction='counterclockwise'):
      pins=[d1,d2,d3,d4]
      if direction=='clockwise':
          pins.reverse()

      for steps in range(250):
          for i in pins:
              i.value(1); time.sleep(0.005); i.value(0)
          steps+=1
          

move()
move('clockwise')

[Rolf M. (rmagnus)]

O. A. schrieb:
> ich habe einen Code in Python welcher einen Stepp-motor antsteuert.
>
> Wie kann ich diesen nun in eine Klasse packen?
>
> Ich habe nur ganz grundlegende Python Kenntnisse..wäre das sehr
> aufwending?

Nein, überhaupt nicht. Stellt der angehängte Code deinen Versuch dar?

Ein Ansatz könnte so aussehen: (ungetestet)

import machine
import time 

class Stepper:
    def __init__(self, d1, d2, d3, d4):
        self.d1 = d1
        self.d2 = d2
        self.d3 = d3
        self.d4 = d4

    def move(self, direction='counterclockwise'):
        pins=[self.d1,self.d2,self.d3,self.d4]
        if direction=='clockwise':
            pins.reverse()

        for steps in range(250):
            for i in pins:
                i.value(1); time.sleep(0.005); i.value(0)
            steps+=1
          
stepper = Stepper(machine.Pin(19, machine.Pin.OUT),
                  machine.Pin(18, machine.Pin.OUT),
                  machine.Pin(17, machine.Pin.OUT),
                  machine.Pin(16, machine.Pin.OUT))

stepper.move()
stepper.move('clockwise')

[Joachim S. (oyo)]

Gerade vor Kurzem hatte hier jemand fast das gleiche Anliegen, da ging 
es auch um Schrittmotor-Steuerung in micropython:
Beitrag "Micropython Stepper-Motor"

Dort habe ich folgenden Code für eine entsprechende 
Schrittmotor-Python-Klasse gepostet, die wie ich finde bereits recht 
komfortabel und konfigurierbar ist.

import machine
import time

def value_with_default(value, default_value):
  return (value or default_value)

class Stepper_Motor():
  def __init__(self, initial_step=None, step_time=None, steps=None, enabled=None, pin_1_id=None, pin_2_id=None, pin_3_id=None, pin_4_id=None):
    self.pin_1 = machine.Pin(value_with_default(pin_1_id, 16), machine.Pin.OUT)
    self.pin_2 = machine.Pin(value_with_default(pin_2_id, 17), machine.Pin.OUT)
    self.pin_3 = machine.Pin(value_with_default(pin_3_id, 18), machine.Pin.OUT)
    self.pin_4 = machine.Pin(value_with_default(pin_4_id, 19), machine.Pin.OUT)
    self.set_steps(steps)
    self.set_step_time(step_time)
    self.set_enabled(enabled)
    self.set_step(initial_step)

  def set_steps(self, steps=None):
    self.steps = value_with_default(steps, [
      [1,0,0,0],
      [1,1,0,0],
      [0,1,0,0],
      [0,1,1,0],
      [0,0,1,0],
      [0,0,1,1],
      [0,0,0,1],
      [1,0,0,1],
    ])
    self.number_of_steps = len(self.steps)

  def set_step_time(self, step_time=None):
    self.step_time = value_with_default(step_time, 0.005)

  def set_pin_states(self, pin_1_state, pin_2_state, pin_3_state, pin_4_state):
    self.pin_1.value(pin_1_state)
    self.pin_2.value(pin_2_state)
    self.pin_3.value(pin_3_state)
    self.pin_4.value(pin_4_state)

  def set_pins(self)
    if self.enabled:
      step_pin_states = self.steps[self.step % self.number_of_steps]
      self.set_pin_states(step_pin_states[0], step_pin_states[1], step_pin_states[2], step_pin_states[3])
    else:
      self.set_pins(0, 0, 0, 0)

  def set_step(self, step=None):
    self.step = value_with_default(step, 0)
    self.set_pins()

  def set_enabled(self, enabled=None):
    self.enabled = value_with_default(enabled, True)
    self.set_step(self.step)

  def move(self, number_of_steps):
    step_delta = 1
    if (number_of_steps < 0):
      step_delta = -1
      number_of_steps = -number_of_steps
    for step in range(number_of_steps):
      self.set_step(self.step + step_delta)
      time.sleep(self.step_time)

  def forward(self, number_of_steps=None):
    self.move(value_with_default(number_of_steps, 1))

  def reverse(self, number_of_steps=None):
    self.move(-value_with_default(number_of_steps, 1))

Mit den von Dir verwendeten Parametern/Pinbelegungen würde man die 
ungefähr so benutzen:
stepper = Stepper_Motor(pin_1_id=19, pin_2_id=18, pin_3_id=17, 
pin_4_id=16, step_time=0.005)
stepper.forward() # (Alternativ: stepper.move(1))
stepper.reverse() # (Alternativ: stepper.move(-1))

[Sven B. (scummos)]

"value_with_default" ist die überflüssigste Utility-Funktion, die ich je 
gesehen habe. Unklarer Name, und die Verwendung ist länger als das 
Syntax-Konstrukt, das darin verpackt wird, jedesmal hinzuschreiben.

[Joachim S. (oyo)]

Sven B. schrieb:
> "value_with_default" ist die überflüssigste Utility-Funktion, die ich je
> gesehen habe. Unklarer Name, und die Verwendung ist länger als das
> Syntax-Konstrukt, das darin verpackt wird, jedesmal hinzuschreiben.

Ja, die Funktion müsste natürlich sinnvollerweise so implementiert sein:

def value_with_default(value, default_value):
  return (value if (value is not None) else default_value)

Über den Namen kann man sich natürlich streiten. Ich persönlich finde 
ihn selbsterklärend, aber wer das anders sieht, kann der Funktion durch 
Suchen-und-Ersetzen natürlich gerne fix einen besseren Namen geben.

[O. A. (sokrates1989)]

Joachim S. schrieb:

> Mit den von Dir verwendeten Parametern/Pinbelegungen würde man die
> ungefähr so benutzen:
> stepper = Stepper_Motor(pin_1_id=19, pin_2_id=18, pin_3_id=17,
> pin_4_id=16, step_time=0.005)
> stepper.forward() # (Alternativ: stepper.move(1))
> stepper.reverse() # (Alternativ: stepper.move(-1))

Vielen Dank für die Hilfe.

Ich habe es mal ausprobiert und wenn ich z.b den forward Befehl in die 
Konsole eingebe bekomme ich folgende Fehlermeldung:

>>> motor.forward()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: function takes 1 positional arguments but 0 were given

Was kann ich da machen?

[Joachim S. (oyo)]

O. A. schrieb:
> Ich habe es mal ausprobiert und wenn ich z.b den forward Befehl in die
> Konsole eingebe bekomme ich folgende Fehlermeldung:
>
>>>> motor.forward()
> Traceback (most recent call last):
>   File "<stdin>", line 1, in <module>
> TypeError: function takes 1 positional arguments but 0 were given
>
> Was kann ich da machen?

Schwer zu sagen, da ja leider keine Zeilennummer angegeben wird, wo der 
Fehler auftreten soll. Da ich kein Micropython verwende, habe ich die 
angegebene Klasse nie getestet, sondern einfach aus dem Kopf 
hingeschrieben. Da kann sich leicht noch ein Fehler eingeschlichen 
haben, und an mindestens einer Stelle gab es tatsächlich noch einen 
Fehler, wie mir eben aufgefallen ist.

Hier daher mal eine leicht verbesserte Version - schau mal, ob der 
Fehler da evtl. schon behoben ist:

import machine
import time

def value_with_default(value, default_value):
  return (value if (value is not None) else default_value)

class Stepper_Motor():
  def __init__(self, initial_step=None, step_time=None, steps=None, enabled=None, pin_1_id=None, pin_2_id=None, pin_3_id=None, pin_4_id=None):
    self.pin_1 = machine.Pin(value_with_default(pin_1_id, 16), machine.Pin.OUT)
    self.pin_2 = machine.Pin(value_with_default(pin_2_id, 17), machine.Pin.OUT)
    self.pin_3 = machine.Pin(value_with_default(pin_3_id, 18), machine.Pin.OUT)
    self.pin_4 = machine.Pin(value_with_default(pin_4_id, 19), machine.Pin.OUT)
    self.step = 0
    self.set_steps(steps)
    self.set_step_time(step_time)
    self.set_enabled(enabled)
    self.set_step(initial_step)

  def set_steps(self, steps=None):
    self.steps = value_with_default(steps, [
      [1,0,0,0],
      [1,1,0,0],
      [0,1,0,0],
      [0,1,1,0],
      [0,0,1,0],
      [0,0,1,1],
      [0,0,0,1],
      [1,0,0,1],
    ])
    self.number_of_steps = len(self.steps)

  def set_step_time(self, step_time=None):
    self.step_time = value_with_default(step_time, 0.005)

  def set_pin_states(self, pin_1_state, pin_2_state, pin_3_state, pin_4_state):
    self.pin_1.value(pin_1_state)
    self.pin_2.value(pin_2_state)
    self.pin_3.value(pin_3_state)
    self.pin_4.value(pin_4_state)

  def set_pins(self):
    if self.enabled:
      step_pin_states = self.steps[self.step % self.number_of_steps]
      self.set_pin_states(step_pin_states[0], step_pin_states[1], step_pin_states[2], step_pin_states[3])
    else:
      self.set_pins(0, 0, 0, 0)

  def set_step(self, step=None):
    self.step = value_with_default(step, 0)
    self.set_pins()

  def set_enabled(self, enabled=None):
    self.enabled = value_with_default(enabled, True)
    self.set_step(self.step)

  def move(self, number_of_steps):
    step_delta = 1
    if (number_of_steps < 0):
      step_delta = -1
      number_of_steps = -number_of_steps
    for step in range(number_of_steps):
      self.set_step(self.step + step_delta)
      time.sleep(self.step_time)

  def forward(self, number_of_steps=None):
    self.move(value_with_default(number_of_steps, 1))

  def reverse(self, number_of_steps=None):
    self.move(-value_with_default(number_of_steps, 1))

[Rolf M. (rmagnus)]

Joachim S. schrieb:
> def forward(self, number_of_steps=None):
>     self.move(value_with_default(number_of_steps, 1))

Warum überhaupt so umständlich, und nicht einfach so?

def forward(self, number_of_steps=1):
    self.move(number_of_steps)

[O. A. (sokrates1989)]

Rolf M. schrieb:

> Ein Ansatz könnte so aussehen: (ungetestet)
>

> stepper = Stepper(machine.Pin(19, machine.Pin.OUT),
>                   machine.Pin(18, machine.Pin.OUT),
>                   machine.Pin(17, machine.Pin.OUT),
>                   machine.Pin(16, machine.Pin.OUT))
> 
> stepper.move()
> stepper.move('clockwise')
>

Wie würde ich dann die Klasse in der Konsole aufrufen, bzw. mit welchem 
Befehl den Motor ansteuern?

[Chris M. (chris_appment)]

Das Programm startest du wie gewohnt in der Konsole

python *Dateipfad/Datei*.py

[Rolf M. (rmagnus)]

O. A. schrieb:
> Wie würde ich dann die Klasse in der Konsole aufrufen, bzw. mit welchem
> Befehl den Motor ansteuern?

??
Das zitierte sind doch schon die dafür nötigen Kommandos.

[Joachim S. (oyo)]

Rolf M. schrieb:
> Joachim S. schrieb:
>> def forward(self, number_of_steps=None):
>>     self.move(value_with_default(number_of_steps, 1))
>
> Warum überhaupt so umständlich, und nicht einfach so?
>
>

> def forward(self, number_of_steps=1):
>     self.move(number_of_steps)
>

Im vorliegenden Fall wäre die von dir gepostete Variante natürlich 
kürzer.

Der Grund, warum ich trotzdem obige Variante genommen habe ist, dass ich 
es mir einfach zur Konvention gemacht habe, in der Funktionsdeklaration 
die default-Werte nicht direkt festzulegen, sondern dort None zu 
notieren. So wird es m.W.n. auch in der Standard-API überwiegend 
gemacht, weil die andere Variante einen kleinen Nachteil hat (siehe z.B. 
hier: 
https://graysonkoonce.com/always-use-none-for-default-args-in-python/ )