LCD Würfel

[Olmato]

Guten Abend

LCD 16X2

ich habe mich nun ein wenig in die Materie "Python" eingefuchst
ich habe mir einen kleinen display würfel geschrieben, das Problem an der ganzen Sache ist das ich eine art Laufschrift auf dem Display habe , ich denke das kommt dadurch dass er einiges in der schleife errechnen muss?

Kann ich denn meinen Code etwas schlanker machen bzw etwas umschreiben das er mir nicht diese "laufschrift" anzeigt

oder liegt das problem an anderer stelle?

Code: Alles auswählen

  import lcddriver
import time as t
from gpiozero import LED, Button
import RPi.GPIO as GPIO
from random import *

GPIO.setmode(GPIO.BCM)
button = Button(4)

lcd = lcddriver.lcd()
lcd.lcd_clear()
lcd.lcd_display_string(" Bitte wuerfeln", 1)

def counter():
    #Dauer
    seconds = 5
    #LCD Leeren
    lcd.lcd_clear()
    #Countdown
    for i in range(seconds):
        x = ("        " + str(seconds-i))
        lcd.lcd_display_string("  Bitte Warten", 1)
        lcd.lcd_display_string(x, 2)        
        #Pause 1 Sek
        t.sleep(1)
        #LCD Leeren
        lcd.lcd_clear()
    lcd.lcd_display_string(bild, 2)
    t.sleep(1)
    #Ende
    lcd.lcd_display_string("  Bitte erneut", 1)
    lcd.lcd_display_string("    wuerfeln", 2)
    
while True:
    button.when_pressed = counter
    augen = randint(1, 12)    
    if augen == 1:
        bild = '       1'
    if augen == 2:
        bild = '       2'
    if augen == 3:
        bild = '       3'
    if augen == 4:
        bild = '       4'
    if augen == 5:
        bild = '       5'
    if augen == 6:
        bild = '       6'
    if augen == 7:
        bild = '       7'
    if augen == 8:
        bild = '       8'
    if augen == 9:
        bild = '       9'
    if augen == 10:
        bild = '       10'
    if augen == 11:
        bild = '       11'
    if augen == 12:
        bild = '       12'  

[sparrow]

Wo wird da denn etwas in der Schleife berechnet?

Wenn das hier das "lcddriver"-Modul ist, das du verwendest, dann schau da mal in den Quellcode und verfolge, was passiert, wenn du die Funktion "display_string" mit einer Zeichenkette fütterst.
Jedes Zeichen wird einzeln an an write übergeben, das tut Dinge und übergibt das Zeichen an write_for_bits, das tut Dinge und übergbt strobe - und dort stehen 2 Aufrufe von sleep. Das Ergebnis ist eine Zeichenkette, die Zeichen für Zeichen auftaucht.

[__blackjack__]

@Olmato: Man sollte das `time`-Modul beim importieren nicht als `t` abkürzen und auch keinen Sternchen-Import aus dem `random`-Modul machen. Das macht den Quelltext nur unnötig undurchsichtiger.

``as`` beim importieren ist zum Umbenennen — `GPIO` wird aber gar nicht umbenannt. Zudem ist der Import überflüssig, weil a) `gpiozero` bereits die BCM-Pin-Nummerierung verwendet und b) gar nicht gesagt ist, das `gpiozero` überhaupt das `RPi.GPIO`-Modul verwendet.

`LED` wird importiert aber nirgends verwendet.

Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst.

Funktion (und Methoden) bekommen alles was sie ausser Konstanten benötigen als Argument(e) übergeben. `counter()` braucht `lcd` als Argument. `counter()` ist kein besonders guter Name für eine Funktion, weil der nicht die Tätigkeit beschreibt die diese Funktion durchführt.

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.

Die ``while``-Schleife macht so überhaupt gar keinen sinn. Da wird ständig die gleiche Funktion als Rückruffunktion für den Knopfdruck zugewiesen — es reicht wenn man das *einmal* macht, und dann wird so schnell die CPU das hergibt gewürfelt und gewürfelt und gewürfelt. Statt das nur zu machen wenn der Benutzer tatsächlich auf den Knopf gedrückt hat. Das Würfeln gehört auch mit in die Rückruffunktion.

Statt da zwölf ``if``\s zu schreiben, hätte man einfach den gewürfelten Wert in eine Zeichenkette formatieren können.

Es wäre weniger umständlich statt `i` von `seconds` abzuziehen wenn man in der Schleife gleich die richtigen Zahlen erzeugen würde. `reversed()` ist da recht praktisch.

Ungetestet:

Code: Alles auswählen

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

import lcddriver
from gpiozero import Button


def display_centered(lcd, text, line):
    lcd.lcd_display_string(text.center(16).rstrip(), line)


def do_countdown_and_dice_roll(lcd):
    for i in reversed(range(6)):
        lcd.lcd_clear()
        display_centered(lcd, "Bitte Warten", 1)
        display_centered(lcd, str(i), 2)
        time.sleep(1)

    lcd.lcd_clear()
    display_centered(lcd, str(randint(1, 12)), 2)
    time.sleep(1)
    display_centered(lcd, "Bitte erneut", 1)
    display_centered(lcd, "wuerfeln", 2)


def main():
    button = Button(4)
    lcd = lcddriver.lcd()
    lcd.lcd_clear()
    display_centered(lcd, "Bitte wuerfeln", 1)
    button.when_pressed = partial(do_countdown_and_dice_roll, lcd)
    signal.pause()


if __name__ == "__main__":
    main()