Pico, Circuitpython, Speed

Ein kompiliertes Python-Programm startet schneller, das läuft nicht schneller, denn das einzige was man sich spart ist die Kompilation zur Laufzeit. Das macht man hauptsächlich um Speicher zu sparen.

Python-Bibliotheken kannst Du von C++ aus nicht verwenden bzw. macht das bei MicroPython & Co keinen Sinn.

Neben MicroPython & Derivaten ist C++ üblich, man kann aber auch andere Programmiersprachen verwenden. Bei anderen Programmiersprachen hat man dann aber das Problem, dass man auf weniger Community und Erfahrung zurückgreifen kann.

Hallo,

wie sieht denn das Programm aus?

Eventuell kann man auch daran schon etwas verbessern.

Grüße

Dennis

Moinsen,

Ich kenne mich nun mit Circuitpython nicht so gut aus, aber du lässt bei den vielen gestaffelten IF Abfragen viel viel Zeit liegen.

Auch wenn schon eine Bedingung wie zB :

    if (i==0):
        Text3=("Taste 1   ")

erfüllt ist, werden auch noch die anderen IFs abgefragt, obwohl das gar nicht mehr notwendig ist. Denn in einem Durchlauf kann ja immer nur ein Zustand zutreffend sein.

Ob man dann schon mit zB einen Break aus dieser einen übergeordneten Schleife herausspringen kann, und ob das Sinn macht, in µPython würde sich diese Methode alternativ zu ELIF anbieten.

Eine weitere Form wäre diese ganzen MODI Abfragen ab Zeile 284 anders zu organisieren.
Das man hier Unterfunktionen nutzt und den Übergabewert an diese Fuktion als LIST Zähler übergibt.
Beispiel :

Tonfolge = [(48, 90 ), # Mode 0
            (48, 48 + 4, 48 + 7 , 90)) # Mode 1

def MODI(table):
    for val in table[:-1]:
         midi.send(NoteOff(val + i, table[-1])

while True:
    MODI(Tonfolge[Modus])

Damit könnte man die Ausführung erheblich beschleunigen, weil die Tuple mit der Stelle gleich dem Modus an diese Funktion übergeben wird, und dann wird nur die letzte Stelle = 90 aus der Betrachtung herausgelöst, und alle davor folgenden Werte in der Schleife "val" von der Stelle 0 bis zur vorletzten Stelle durchlaufen.

Woher nun "Modus kommt und wie das interagiert ist gar nicht so einfach zu überblicken. Aber diese Anwendungsform alle Festwerte über eine LIST mit Tuple bereitzustellen, welche ohne IF abfrage nur zugewiesen aufgerufen werden müssen, bringt einfach nur Geschwindigkeit.

Ob das so in Circuitpython zu 100 % genauso funktioniert wie in µPython kann ich dir leider nicht sagen. Ich stehe damit ( Circuitpython ) auf Kriegsfuß.

Micki Globale Variablen setzt man richtig in dem man sie gar nicht benutzt. Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht in einer Funktion die üblicherweise `main()` heisst. Alles was eine Funktion/Methode ausser Konstanten benötigt, wird als Argument(e) übergeben. Globale Variablen sind ja an sich schon unübersichtlich, aber dann auch noch eine die überall einfach global existiert und verwendet wird `i` zu nennen habe ich das erste mal gesehen. (Stimmt nicht so ganz — bei klassischen BASIC-Programmen mit Zeilennummern habe ich das natürlich schon gesehen.)

Namen werden in Python klein_mit_unterstrichen geschrieben. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (MixedCase).

Man nummeriert keine Namen. Dann will man sich entweder sinnvollere Namen überlegen, oder gar keine Einzelwert und -namen sondern eine Datenstruktur. Oft eine Liste.

Man muss nicht jedes kleine Zwischenergebnis an einen Namen binden.

So einige Namen sind auch nicht gut. Neben dem `i` beispielsweise so etwas wie `Zahl`. Wenn dann da ein Kommentar dran steht der sagt, dass da der Modus verglichen wird, sollte `Zahl` vielleicht einfach `modus` heissen und schon kann man sich den Kommentar sparen.

Da ist viel Code der nach kopiert und leicht angepasst aussieht. Das macht man nicht. Dafür gibt es Schleifen und/oder Funktionen, beziehungsweise kann man da sicher auch Sachen in Datenstrukturen aus dem Code herausziehen.

Eine Funktion sollte jeweils eine in sich geschlossene Tätigkeit durchführen. Wenn man Funktionen hat die aufgrund eines Arguments (hier noch eine globale Variable) einen jeweils anderen Weg durch die Funktion geht, dann ist der Code falsch aufgeteilt. Statt beispielsweise mehrere Funktionen zu haben die pro Modus jeweils etwas anderes macht, bräuchte man eine Funktion pro Modus, beziehungsweise wahrscheinlich ein Objekt pro Modus. So das alles für einen Modus übersichtlich zusammengefasst ist, und man die Modi leicht ändern, erweitern, oder herausnehmen kann.

Micki Da in der Funktion immer alle Texte geschrieben werden, nacheinander, wären das keine Einzelwerte sondern besser eine Liste. Und so wie ich das sehe wird die Funktion zu oft aufgerufen.

Bei der Tastenabfrage wäre es effizienter wenn man sich die 16 Bit merkt, und mit der „exklusiv oder“-Bitverknüpfung (Operator ``^``) prüft welche Bits, also Tasten sich seit dem letzten mal geändert haben (und auch ob sich überhaupt welche geändert haben), und dann kann man beide Werte Bit für Bit durchgehen und überall wo sich etwas geändert hat, schauen was im neuen Wert dort steht, und hat da damit auch gleich ob die Taste jetzt neu gedrückt ist, oder losgelassen wurde. Und *das* würde man dann am besten in eine Generatorfunktion verfrachten und ist damit dann schon mal mehrere globale Variablen losgeworden.

Der ”Trick” Daten und dazugehörende Funktionen zusammenzubringen sind Klassen. Also letztlich wie in C++.

Moinsen Micki

diese ganze Displaydarstellung wenn du ein festes Zeilenraster verwendest kannst du wie __blackjack__ schon sagte in eine Funktion auslagern, dazu wieder eine LIST und eine Funktion verwenden.

def renew_display(display, texts):
    display_posistions = [(0, 0), (0, 12), (0, 24), 
                          (75, 0), (75, 12), (75, 24),
                          (48, 0)]
    display.fill(0)                
    for num in range(6):
        display.text(texts[num],
                     display_posistions[num][0],
                     display_posistions[num][1], 1)
    display.text(f'{texts[-1]}',
                 display_posistions[-1][0],
                 display_posistions[-1][1], 1)
    display.show()

Display_Lines = ['' for _ in range(7)] # damit werden 7 leere Platzhalter erzeugt

Display_Lines[0) = 'Text 1 für erste Zeile'
Display_Lines[1] = 'Text 2 für zweite Zeile'
Display_Lines[-1] = 78
renew_display(oled, Display_Lines)

Ebenso macht es wenig Sinn wie in den Zeilen

oled.fill(0) # Originalcode / ggf fehlerhaft

oled.text("Controller 2023 25", 0, 12, 1)
time.sleep(4)
oled.show()

ein Sleep zu verwenden, wenn die Displayaktuallisierung = oled.show() verzögert wird. Ich denke du beabsichtigst diesen Inhalt für 4 Sekunden darzustellen als Startbildschirm, damit dieser 4 Sekunden vor Beginn des Programmlaufes angezeigt wird ?

from utime import sleep

Display_lines[0] = 'Controller 2023 25'
renew_display(oled, Display_Lines)
sleep(4)

So könnte das mit der zuvor erstellten Funktion aussehen.
Um eine einzelne Zeile wieder zu löschen müsste man nur:

Display_lines[2] = '' # entspricht der Zeile mit der Position x0 y24
renew_display(oled, Display_Lines)

Damit erspart man sich nicht nur die vielen globalisierten Variablen, sondern hat auch eine festes Objekt = LIST welches den aktuellen Displayinhalt aufbewahrt, bzw. zwischenspeichert.

Damit kein Zeilenüberlauf bei zu langen Texten entsteht könnte man diese Strings auch noch in der Länge beschneiden, könnte man diesen String einer Zeile noch auf die maximal Länge beschneiden.

text = 'bla123bla456bla789'
print(text[:1]) # würde jetzt nur das erste 'b' anzeigen
print(text[:5]) # würde jetzt 'bla12' ausgeben

dieses [:<Stelle>] kann man somit dazu nutzen, eine String auf eine bestimmte Länge einzukürzen.

Wie Dennis89 und __blackjack__ immer wieder betonen, mit Funktionen, welche eine feste Aufgabe haben, denen alle notwendigen Dinge / Parameter übergeben werden, und einen ganz klar definierten spezifischen Umfang haben, aber auch nicht überladen sind mit zu viel Schnickschnack macht das Arbeiten und spätere Korrekturen einfacher. Zudem kann man sich viele Einzelabfragen mit IF ersparen, wenn die Datenbasis in LISTs [ variable Inhalte ] oder Tuple [ konstante Werte ] gesteckt werden.

Was ich jetzt in diesem Zusammenhang nicht verstehe ist die Auswertung mehrerer gleichzeitig gedrückter Taten. Diese Kombinationsmöglichkeiten sind auf Grund deines Codes nicht ersichtlich, welche Kombinationen zulässig sind.

Hier wäre eine klare Beschreibung der Arbeitsparameter von Nöten.

Die Positionen für die Texte könnte man auch ausrechnen (ungetestet):

def update_display(oled, texts, number):
    oled.fill(0)
    for text, (x, y) in zip(
        texts, ((i // 3 * 75, i * 12 % 36) for i in range(6))
    ):
        oled.text(text, x, y, 1)
    oled.text(str(number), 48, 0, 1)
    oled.show()

Oder wenn man das in eine Klasse steckt am besten auch nur *einmal* als Konstante auf der Klasse definiert, und statt `oled`, `texts`, und `number` (und `I2c`) dann nur noch ein Name für das Display im Hauptprogramm:

class Display:
    TEXT_POSITIONS = [(i // 3 * 75, i * 12 % 36) for i in range(6)]
    NUMBER_POSITION = (48, 0)

    def __init__(self, scl, sda):
        self.oled = adafruit_ssd1306.SSD1306_I2C(128, 32, busio.I2C(scl, sda))
        self._texts = [""] * 6
        assert len(self._texts) == len(self.TEXT_POSITIONS)
        self.number = 0

    def set_text(self, index, value):
        self._texts[index] = value

    def update(self):
        self.oled.fill(0)
        for text, (x, y) in zip(self._texts, self.TEXT_POSITIONS):
            self.oled.text(text, x, y, 1)
        self.oled.text(str(self.number), *self.NUMBER_POSITION, 1)
        self.oled.show()

Falls es Sinn macht, könnte man auch noch ein ”dirty”-Flag einbauen so das `update()` nur etwas tut wenn sich der Inhalt auch geändert hat.

Moinsen,

was mir ebenfalls aufgefallen:

def ModusName(Zahl):
    if Zahl == 0:
        global Text4
        Text4 = ("Noten")
        ausgabe(Text4)
    if Zahl == 1:
        global Text4
        Text4 = ("Chords")
        ausgabe(Text4)
    if Zahl == 2:
        global Text4
        Text4 = ("Chd-Scale")
        ausgabe(Text4)
    if Zahl == 3:
        global Text4
        Text4 = ("Dur+Moll")
        ausgabe(Text4)
    if Zahl == 4:
        global Text4
        Text4 = ("Functions")
        ausgabe(Text4)

Was für eine Wahnwitz

def ModusName(number):
    menue_text = ('Noten', ('Chords'), ('Chd-Scale'), ('Dur+Moll'), ('Functions')
    if 0<= number <= 4:
        return menue_text[number]
    return ''

Display_lines[3] = ModusName(<Quelle der Nummer>)

Jede Ziffer in der übergebene Zahl zwischen 0 und 4 befüllt die Zeile 4 mit dem zugeordneten Textinhalt, und alles andere würde eine löschen bzw. leere Zeile bewirken.

Es geht somit komplett ohne IF was einfach nur wieder Geschwindigkeit bedeutet

Moinsen Micki

Wie hiess der Ballermann Song "Es ist Wahnsinn ... "

                if (i==0):
                    Text3=("Taste 1   ")                   
                if (i==1):
                    Text3=("Taste 2   ")                    
                if (i==2):
                    Text3=("Taste 3   ")                                    
                if (i==3):
                    Text3=("Taste 4   ")                    
                if (i==4):
                    Text3=("Taste 5   ")                   
                if (i==5):
                    Text3=("Taste 6   ")                     
                if (i==6):
                    Text3=("Taste 7   ")                
                if (i==7):
                    Text3=("Taste 8   ")                
                if (i==8):
                    Text3=("Taste 9   ")                 
                if (i==9):
                    Text3=("Taste 10  ")                 
                if (i==10):
                    Text3=("Taste 11  ")                 
                if (i==11):
                    Text3=("Taste 12  ")                 
                if (i==12):
                    Text3=("Taste 13  ")                 
                if (i==13):
                    Text3=("Taste 14  ")                 
                if (i==14):
                    Text3=("Taste 15  ")                
                if (i==15):
                    Text3=("Taste 16  ")
                ausgabe(Text)

Du musst dich echt nicht wundern das bei den vielen IF auf IF und IF deine Laufzeit flöten geht:

def button_select(number):
    if 0 <= number <= 15:
        return f'Taste {number + 1:2d}   '
    # hier kann noch Code folgen, wenn diese Bedingung nicht erfüllt ist, was dann passieren soll

Display_lines[3] = button_select(i)
renew_display(oled, Display_Lines)

Falls du noch eine Ausnahme benötigst einfach dahinter / darunter weiter machen.
Dieses Return mit dem schon formatierten Text zur Displayzeile 4 beendet damit vorzeitig diese Funktion. Wenn diese Bedingung nicht erfüllt ist geht es danach weiter als wäre nichts gewesen und man spart sich auch eine weiteres ELSE oder ELIF.
Die Ausgabe :<Stellen>d bewirkt eine rechtsbündige Formatierung für 2 VK-Stellen.

Moinsen Micki ,

jetzt kenne ich dir Konfiguration bei dir nicht. Aber das OLED kann man mit Dunst Fahren.
So wie ich das sehe fährst du den I²C im langsamsten Modus.

Gibt erst einmal Gas, in dem du die SCL Frequenz auf 400 kHz erhöhst.

https://learn.adafruit.com/todbot-circuitpython-tricks/i2c

Damit bist du schon mal eine Bremse los.

Moinsen Micki

Quote from Micki

Meine Fragen wäre nun:

- Habt ihr eine Idee, wie man eine Textausgabe auf das OLED hinbekommt, ohne den Hauptprozess zu verzögern? Es wäre ja doch schön zu sehen, unter welchem Modus man gerade arbeitet und welche Taste man gerade drückt.

- Außerden möchte ich mal genauer wissen, wieviel Zeit für welchen Prozess draufgeht. Beim Arduino gabt es Millis. Gibt es was ähnliches auch beim Pico?

- Und, ich würde den Pico gerne sauber runterfahren, wenn ich fertig bin. Kennt ihr eine Routine?

Zur Frage 1: Diese OLEDs 0,96" gibt es in drei Ausführungen ! Ohne eine Spezifizierung kann man hier nur raten.
Es gibt die reine 5 Volt Variante die auch notdürftig auch mit 3,3 V Vc und 3,3 Volt Pegeln was auf die Matschscheibe zaubert, aber nur wegen der Pegelakzeptanz. Diese sind bei auch nur Vc 3,3 Volt extrem langsam.
Dann gibt es diese Displays, die eine 3,3/5,0 V Spezifizierung haben, auf die explizit hingewiesen wird. Diese kann man bis SCL- Takt 400 kHz betreiben, was schon einmal ein Fortschritt wäre, um deinen Speed Problem aus dem Weg zu gehen.
Und dann gibt es diese Displays als "Only 3,3 V" Variante. Diese mit guter Kühlung, also nicht eingepfercht in einem Kasten mit anderen Abwärme produzierenden Dingen kann man via SCL-Takt stabil bis 580 kHz fahren. Allerdings wie bei jedem OLED mit reduzierter Lebensdauer. 400 kHz sind hierbei im sicheren Bereich.

Alternativ du hast eine Thread im zweiten Core welcher via Timer Event ( dann aber nur über eine Klase ) das Display automatisch und regelmäßig aktualisiert. Je nach Umfang der Displayfüllung erreicht man mit einem Single Thread hier Aktualisierungsraten von unter 100 ms also 10 + Aktualisierungen pro Sekunde.
Zur zweiten Frage:
Normal steht in der Bibliothek TIME die Funktionen um ticks_xx zur Verfügung. Damit kann man in ticks_ms in Millisekunden oder mit ticks_us in Miicrosekunden , oder ticks_cpu die benötigten CPU Takte erfassen. [ µPython ]
Jetzt bin ich noch nicht dahinter gestiegen wie man in Circuitpython die CPU Frequenz abfragen / manipulieren kann. In µPython aber auch in Circuitpython läuft die CPU verlangsamt auf 125 MHZ statt mit 133 MHz. In [µPython] kann man das mit machine.freq(133_000_000) machen, das man hier schon einmal paar Sekündchen herausholt.

Zu deiner Letzten Frage: Der PICO ist ein µController ohne BS ( Betriebssystem ) und muss nicht herunter gefahren werden. Wenn du keine File-Zugriffe auf das VS machst ist es normal nicht notwendig hier besondere Vorsichtsmaßnahmen zu ergreifen.

Moinsen Micki

was meinst du mit verdoppeln ?

Wenn du den I²C Bus ansprichst, dann sind 400 kHz statt 100 kHz ( Standard bei Circuitpython ) schon einmal nur 1/4tel. Und der Rest das hängt an dieser grottigen Bibliothek von Circuitpython. DIeser Aufbau über BUSIO und den ganzen anderen Geböns ist einfach nur grotten Langsam.

Das die einfaches Threading nicht unterstützen, musst du damit vorlieb nehmen .