Funktion vereinfachen (statt t1,t2,t3,...) mit Index-Zählvariable (ti) arbeiten

Jonny98731 · Oct 27th 2020

Hallo liebe Forenmitglieder,

Sorry für den Titel, ich weiß nicht genau wie ich mein Problem in einem Satz sonst zusammenfassen soll.

Kurz zum Projekt: Ich habe 16 Schalter mit denen ich über 2 Schieberegister 16 LED bei Tastendruck individuell ein und ausschalten möchte.

Bisher hab ich zum Ausprobieren nur 3 Schalter angeschlossen.

Ich habe eine Menge Funktionen und Schleifen, die jeweils auf eine bestimmte Variable angewandt werden.

Z.B. muss ich folgende Funktion (Taster1) für alle anderen Taster umkopieren und die Indizes auf 2,3,4,5 usw. ändern, was insgesamt bei 16 Tastern sehr lang und unübersichtlich wird.

Code

# Callback-Funktion SCHALTER 1
def Tasterfunktion1(channel):
  global t1
  # Counter auf 0 und 1 umschalten
  if t1 == 1:
      t1 = 0
  else:
      t1 = 1
  print("TASTER1 " + str(t1))

# Callback-Funktion SCHALTER 2
def Tasterfunktion2(channel):
  global t2
  # Counter auf 0 und 1 umschalten
  if t2 == 1:
      t2 = 0
  else:
      t2 = 1
  print("TASTER2 " + str(t2))

usw.

Display More

Ein anderes gutes Beispiel ist dieses hier:

Code

#tasteränderung festhalten
taster1x = t1
taster2x = t2
taster3x = t3

while 1:
    if t1 != taster1x or t2 != taster2x or t3 != taster3x:
        GPIO.output(OE,1)
        out = [t1,t2,t3,t1,t2,t3,t1,t2,t3,t1,t2,t3,t1,t2,t3,t1,t2]      
        ausgabe()
        time.sleep(0.01)
        GPIO.output(OE,0)

        #tastenänderung rücksetzen
        taster1x = t1
        taster2x = t2
        taster3x = t3

Display More

Die if - Bedingung wird hier durch die ganzen "or"'s sehr sehr lang. Auch alle alle ti und tasterix werden eine lange Liste abgeben.

Nachfolgend der gesamte bisherige Code. Dort lässt sich an einigen Stellen mein Problem finden.

Der Teil mit den Schieberegistern usw. ist jetzt nicht weiter für meine Fragestellung wichtig und darf ignoriert werden.

Mich interessiert nur, ob es einen Weg gibt, mit einer Art Schleife alle (obiges Beispiel) 16 t-Variablen mithilfe eines arrays oder so in einer einzelnen Schleife durchzählen zu lassen und auszuwerten.

Python

#!/usr/bin/python
import RPi.GPIO as GPIO     #GPIO definieren
import time,os              # importieren von Bibliotheken
GPIO.setwarnings(False)     # Keine Warnungen anzeigen
GPIO.cleanup()              #GPIOs zurücksetzen

# Pinreferenz waehlen
GPIO.setmode(GPIO.BCM)

#Pinvariablen zuweisen
SER = 13
RCLK = 19
SRCLK = 26
OE = 21

#GPIO Setup LED
GPIO.setup(SER,GPIO.OUT)      # Setze Pin 5 als Ausgang (SER) DATEN
GPIO.setup(RCLK,GPIO.OUT)      # Setze Pin 6 als Ausgang (SCK) SCHIEBT WEITER
GPIO.setup(SRCLK,GPIO.OUT)      # Setze Pin 26 als Ausgang (RCK) SCHIEBT IN SPEICHER
GPIO.setup(OE,GPIO.OUT)      # Setze Pin 1 als BLANK - Wenn high, dann Ausgänge low
t=0.0001

#Tasterpositionen zuweisen (PT kurz für Position Taster BCM)
PT1 = 2
PT2 = 3
PT3 = 4

#GPIO Setup Taster als Input definieren und Pullup-Widerstand aktivieren
GPIO.setup(PT1, GPIO.IN, pull_up_down = GPIO.PUD_UP) #Taster1
GPIO.setup(PT2, GPIO.IN, pull_up_down = GPIO.PUD_UP) #Taster2
GPIO.setup(PT3, GPIO.IN, pull_up_down = GPIO.PUD_UP) #Taster2

#Tastervalues definieren, nullsetzen
t1 = 0
t2 = 0
t3 = 0


# Callback-Funktion SCHALTER 1
def Tasterfunktion1(channel):
  global t1
  # Counter auf 0 und 1 umschalten
  if t1 == 1:
      t1 = 0
  else:
      t1 = 1
  print("TASTER1 " + str(t1))
  
  
# Callback-Funktion SCHALTER 2
def Tasterfunktion2(channel):
  global t2
  # Counter auf 0 und 1 umschalten
  if t2 == 1:
      t2 = 0
  else:
      t2 = 1
  print("TASTER2 " + str(t2))
  
  # Callback-Funktion SCHALTER 3
def Tasterfunktion3(channel):
  global t3
  # Counter auf 0 und 1 umschalten
  if t3 == 1:
      t3 = 0
  else:
      t3 = 1
  print("TASTER3 " + str(t3))
  
# LED Funktionsdefinierung ab hier

def ausgabe():
    for y in reversed(range(-1,len(out))):
        GPIO.output(SER,out[y])     # eine 1 an den seriellen Input senden
        time.sleep(t)         # 100ms warten
        GPIO.output(RCLK,1)          # SCK-Pin auf High ziehen, damit das Register anfaengt die Bits um eine Stelle zu verschieben
        time.sleep(t)         # 100ms warten
        GPIO.output(RCLK,0)          # SCK_Pin wieder auf LOW ziehen
        GPIO.output(SRCLK,1)                  # RCK auf HIGH setzen, damit das Register zur Ausgabe kopiert wird
        time.sleep(t)                 # 100ms warten
        GPIO.output(SRCLK,0)                  # RCK wieder auf LOW setzen
        
#Hier beginnt der eigentliche Ablauf
        
        
# Interrupt-Event hinzufuegen, fallende Flanke
GPIO.add_event_detect(PT1, GPIO.FALLING, callback = Tasterfunktion1, bouncetime = 500)  
GPIO.add_event_detect(PT2, GPIO.FALLING, callback = Tasterfunktion2, bouncetime = 500)
GPIO.add_event_detect(PT3, GPIO.FALLING, callback = Tasterfunktion3, bouncetime = 500)

#LED Programm


#tasteränderung festhalten
taster1x = t1
taster2x = t2
taster3x = t3

while 1:
    if t1 != taster1x or t2 != taster2x or t3 != taster3x:
        GPIO.output(OE,1)
        out = [t1,t2,t3,t1,t2,t3,t1,t2,t3,t1,t2,t3,t1,t2,t3,t1,t2]      
        ausgabe()
        time.sleep(0.01)
        GPIO.output(OE,0)

        #tastenänderung rücksetzen
        taster1x = t1
        taster2x = t2
        taster3x = t3

Display More

Wenn die Aufgabenstellung und das Problem unklar ist, gerne fragen, womöglich hab ichs ein bisschen verkorkst formuliert...

Ich hoffe jemand hat eine Idee.

Tell · Oct 27th 2020

Da gibt es ganz verschiedene Loesungsansaetze, je nachdem was genau resultieren soll...

Fuer das erste Codestueck koennte man mit einem Array arbeiten:

Code

status = [0,0,0,0,0,0,...]

# Was steht in channel?
def Tasterfunktion1(channel, status, index ):
    status[index] = (status[index] + 1) % 2
    print( f"TASTER{index+1] {status[index]" )

Kelvin · Oct 27th 2020

Quote from Jonny98731

Z.B. muss ich folgende Funktion (Taster1) für alle anderen Taster umkopieren und die Indizes auf 2,3,4,5 usw. ändern, was insgesamt bei 16 Tastern sehr lang und unübersichtlich wird.

Das geile an Funktionen ist, dass sie sich prima für wiederholende und leicht unterschiedliche Variablen eignen. Anstatt deine Funktion für t1, t2, ... zu schreiben, kannst du einfach tx übergeben und so abstrahieren. In dem Schritt kannst du auch gleich auf das global verzichten und mit return arbeiten:

Python

def TasterfunktionX(channel, tx, name):
  # Counter auf 0 und 1 umschalten
  if tx == 1:
    tx = 0
  else:
    tx = 1
  print("TASTER " + name + str(tx))
  return tx

# Aufruf
channel = 0  # ist uns unbekannt
t2 = 0
t2 = TasterfunktionX(channel, t2, "irgendeinName")
print(t2)  # 1

Display More

Deine Tasterfunktion heißt im englischen übrigens "Toggle". Wenn 1, dann mache 0 und wenn 0, dann mache 1 -> also immer genau das Gegenteil. Hier ist eine elegantere Lösung (https://stackoverflow.com/a/8381955/2153629):

Python

def TasterfunktionX(channel, tx, name):
  tx ^= 1  # setze tx auf das Gegenteil
  print("TASTER " + name + str(tx))
  return tx

Tell · Oct 27th 2020

Alles was das machen soll ist Ausgang = Eingang??

Dann ist dieses Programm aber viel zu kompliziert.

* status = 0

* Schalter 1 setzt Bit 1 von status

* Schalter 2 setzt Bit 2 von status

.

Die Ausgabefunktion wird angepasst so dass sie die Bits von status auf das Schieberegister ausgibt

__blackjack__ · Oct 27th 2020

Jonny98731 Du solltest als erstes mal kein Python 2 mehr verwenden.

Eingerückt wird mit vier Leerzeichen pro Ebene.

``as`` beim Import ist zum umbenennen, `GPIO` wird aber gar nicht umbenannt. `os` wird importiert, aber nirgends verwendet.

Kommentare sollen dem Leser einen Mehrwert über den Code geben. Faustregel: Kommentare beschreiben nicht *was* der Code macht, denn das steht da bereits als Code, sondern warum er das macht. Sofern das nicht offensichtlich ist. Offensichtlich ist in aller Regel auch was in der Dokumentation von Python und den verwendeten Bibliotheken steht. So etwas wie ``# importieren von Bibliotheken`` bei einem ``import`` oder ``# Keine Warnungen anzeigen`` bei einem ``GPIO.setwarnings(False)`` ist einfach nur überflüssig.

Wirklich schlecht sind Kommentare die offensichtlich dem Code widersprechen, denn dann weiss der Leser nicht wer Recht hat, der Kommentar oder der Code. Und damit erreicht der Kommentar dann das Gegenteil von seiner Funktion: Statt fragen zu klären, wirft er neue auf. Ein Grund Redundanz in Kommentaren zu vermeiden, wie im Beispiel die Pinnummern die nicht mit denen im Code übereinstimmen. Und auch die Konstantennamen in den Kommentaren weichen von den Konstantennamen im Code ab. Warum?

Auch ein falscher Kommentar ist das ``# 100ms warten`` was noch nicht mal leicht als falsch zu erkennen ist, weil `t` ganz woanders, ausserhalb der Funktion definiert ist. Dort ist das nicht 0.1, was 100ms wären, sondern 0.0001, was 0.1ms oder 100µs wären. Was ist da jetzt falsch? Die Zahl im Code oder die Einheit im Kommentar?

Man sollte weder die Warnungen unterdrücken, noch am Anfang vom Code `cleanup()` aufrufen. Dieser Aufruf gehört an das Ende vom Programmablauf, mit einem ``try``/``finally`` abgesichert, so dass es auch aufgerufen wird, falls eine unerwartete Ausnahme auftritt.

Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst. Was man gar nicht machen sollte ist auf Modulebene Konstanten, Variablen, Funktionen, und Hauptprogramm fröhlich abwechselnd mischen. Da muss man am Ende das gesamte Programm an einem Stück kennen und nachvollziehen können, statt das man sich einzelne Funktionen getrennt anschauen kann.

Namen sollten keine kryptischen Abkürzungen enthalten oder gar nur daraus bestehen. Wenn man einen Kommentar braucht, der das in Langform erklärt, dann sollte der Name diesen Kommentar überflüssig machen.

Man nummeriert keine Namen. Man will dann entweder sinnvolle Einzelnamen, oder gar keine einzelnen Werte sondern eine Datenstruktur. Oft eine Liste. Wie auch in diesem Fall.

Du hast da 17 Werte für 16 LEDs und ein Wert davon wird auch noch zweimal in der Schleife in `ausgabe()` verarbeitet — also insgesamt 18 Schleifendurchläufe. Soll das so‽

Man sollte Zahlen nicht als Wahrheitswerte missbrauchen. Python hat einen eigenen Datentyp (`bool`) mit den Werten `True` und `False` dafür.

Gehört das mit dem BLANK-Pin nicht auch in die `ausgabe()`?

Zwischenstand (ungetestet):

Python

#!/usr/bin/env python3
import time
from functools import partial

from RPi import GPIO

SER_PIN = 13
SCK_PIN = 19
RCK_PIN = 26
BLANK_PIN = 21
LED_PINS = [SER_PIN, SCK_PIN, RCK_PIN, BLANK_PIN]

TASTER_PINS = [2, 3, 4]


def umschalten(taster_werte, index, _channel=None):
    wert = not taster_werte[index]
    taster_werte[index] = wert
    print(f"TASTER{index + 1} = {wert}")


def bits_ausgeben(bits):
    GPIO.output(BLANK_PIN, 1)

    for bit in reversed(bits):
        GPIO.output(SER_PIN, bit)
        time.sleep(0.0001)
        #
        # SCK-Pin auf HIGH ziehen, damit das Register anfaengt die Bits um eine
        # Stelle zu verschieben.
        #
        GPIO.output(SCK_PIN, 1)
        time.sleep(0.0001)
        GPIO.output(SCK_PIN, 0)
        #
        # RCK auf HIGH setzen, damit das Register zur Ausgabe kopiert wird.
        #
        GPIO.output(RCK_PIN, 1)
        time.sleep(0.0001)
        GPIO.output(RCK_PIN, 0)

    time.sleep(0.01)
    GPIO.output(BLANK_PIN, 0)


def main():
    try:
        GPIO.setmode(GPIO.BCM)

        GPIO.setup(LED_PINS, GPIO.OUT)
        GPIO.setup(TASTER_PINS, GPIO.IN, pull_up_down=GPIO.PUD_UP)

        taster_werte = [False] * len(TASTER_PINS)
        
        for index, pin in enumerate(TASTER_PINS):
            GPIO.add_event_detect(
                pin,
                GPIO.FALLING,
                callback=partial(umschalten, taster_werte, index),
                bouncetime=500,
            )

        alte_taster_werte = list(taster_werte)
        while True:
            if taster_werte != alte_taster_werte:
                #
                # Taster-Werte wiederholen damit 16 Bits erreicht werden.
                #
                bit_count = 16
                bits = (taster_werte * (bit_count // len(taster_werte) + 1))[
                    :bit_count
                ]
                bits_ausgeben(bits)
                alte_taster_werte = list(taster_werte)
    finally:
        GPIO.cleanup()


if __name__ == "__main__":
    main()

Display More

Das ist vom Prinzip her das was Du machen wolltest, aber es hat zwei Probleme:

1. Es besteht eine kleine zeitliche Lücke in der Tastendrücke nicht sofort berücksichtigt werden, sondern erst wenn der nächste Tastendruck erkannt wird.

2. Die ``while``-Schleife beschäftigt die CPU zu 100% mit „busy waiting“.

Beides würde man mit einer `Queue` lösen in die die Rückruffunktion das Ereignis schreibt und die man in der Hauptschleife blockierend abfragt.

Wieder ungetestet:

Python

#!/usr/bin/env python3
import time
from functools import partial
from queue import Queue

from RPi import GPIO

SER_PIN = 13
SCK_PIN = 19
RCK_PIN = 26
BLANK_PIN = 21
LED_PINS = [SER_PIN, SCK_PIN, RCK_PIN, BLANK_PIN]

TASTER_PINS = [2, 3, 4]


def bits_ausgeben(bits):
    GPIO.output(BLANK_PIN, 1)

    for bit in reversed(bits):
        GPIO.output(SER_PIN, bit)
        time.sleep(0.0001)
        #
        # SCK-Pin auf HIGH ziehen, damit das Register anfaengt die Bits um eine
        # Stelle zu verschieben.
        #
        GPIO.output(SCK_PIN, 1)
        time.sleep(0.0001)
        GPIO.output(SCK_PIN, 0)
        #
        # RCK auf HIGH setzen, damit das Register zur Ausgabe kopiert wird.
        #
        GPIO.output(RCK_PIN, 1)
        time.sleep(0.0001)
        GPIO.output(RCK_PIN, 0)

    time.sleep(0.01)
    GPIO.output(BLANK_PIN, 0)


def main():
    try:
        GPIO.setmode(GPIO.BCM)

        GPIO.setup(LED_PINS, GPIO.OUT)
        GPIO.setup(TASTER_PINS, GPIO.IN, pull_up_down=GPIO.PUD_UP)

        queue = Queue()
        for index, pin in enumerate(TASTER_PINS):
            GPIO.add_event_detect(
                pin,
                GPIO.FALLING,
                callback=partial(queue.put, index),
                bouncetime=500,
            )

        taster_werte = [False] * len(TASTER_PINS)
        while True:
            index = queue.get()
            neuer_wert = not taster_werte[index]
            print(f"TASTER{index + 1}: {neuer_wert}")
            taster_werte[index] = neuer_wert
            #
            # Taster-Werte wiederholen damit 16 Bits erreicht werden.
            #
            bit_count = 16
            bits = (taster_werte * (bit_count // len(taster_werte) + 1))[
                :bit_count
            ]
            bits_ausgeben(bits)
    finally:
        GPIO.cleanup()


if __name__ == "__main__":
    main()

Display More

Funktion vereinfachen (statt t1,t2,t3,...) mit Index-Zählvariable (ti) arbeiten

Tags

Users Viewing This Thread