Beiträge von ClaudiaF

Zitat von SLiX

Der Sinn davon ergibt sich mir (noch?) nicht. Ist es noch ein Singleton wenn es eine Unterklasse bzw ein Objekt dieser gibt?

Im Sinne von die ableitende Klasse überschreibt nicht sondern erweitert, dann ja, dann sollte am Ende immer noch nur ein
singleton objekt existieren. Das Beispiel mag jetzt nicht 100% sinnig sein, sollte nur zeigen das jemand der nur einen anderen
Ansatz fährt das Konzept zunichte machen kann. Und dabei geht es nicht um absichtliches zerstören sondern nur weil evtl. fehlerhaft
implementiert oder interpretiert.

Zitat von SLiX

Klar stimmt schon. Wenn es jetzt wirklich nur eine Variable sein soll, ist ein Singleton echt overkill

Es wird wahrscheinlich der seltenste Fall sein, das Hobbyprogrammierer tatsächlich auf dieses Problem stoßen.
Und zu 99% würden Ansätze wie oben dies wahrscheinlich lösen aber wenn ich ein Projekt habe, dass ich nach außen geben will,
sprich open source oder freeware mit plugin interface etc... dann sollte schon bewußt sein, dass dies evtl. meine Anwendung
in Bedrängnis bringen kann.

Cheers
Claudia

Ist dir aufgefallen, dass der Stepper warm ist und bleibt nachdem dieser was getan hat?
Oder evtl. schon/nur vorher.

Wenn vorher, dann ist wahrscheinlich der setup schuld.
Im setup der ino wird der Port auf HIGH gesetzt.

// prepare STBY GPIO and set Stepper motors
  pinMode(STBY, OUTPUT);
  digitalWrite(STBY, HIGH);

da bleibt es solange, bis der Port im main loop neu gesetzt wird

else if (req.indexOf("/stepper/stop") != -1) {
    digitalWrite(STBY, LOW);
    respMsg = "OK: MOTORS OFF";
  } 
  else if (req.indexOf("/stepper/start") != -1) {
    digitalWrite(STBY, HIGH);
    blink();
    respMsg = "OK: MOTORS ON";
  }

daher würde ich im setup den Port eher auf LOW setzen.

Ansonsten sehe ich im ersten Moment nur die Möglichkeit,
das im Pythonmodule

def doStepper(steps):
    if (steps == 0):
        return
    try:
       stepperUrl = STEPIP
       cmd = stepperUrl+"stepper/start"
       resp = urllib2.urlopen(cmd)
       if DEBUG:
           print (cmd)
           print resp.read()
       resp.close()
       time.sleep(0.1) # keep from overflowing ESP wifi buffer
       cmd = stepperUrl+"stepper/rpm?10"
       resp = urllib2.urlopen(cmd)
       if DEBUG:
           print (cmd)
           print resp.read()
       resp.close()
       time.sleep(0.1) # keep from overflowing ESP wifi buffer
       cmd = stepperUrl+"stepper/steps?"+str(steps)
       resp = urllib2.urlopen(cmd)
       if DEBUG:
           print (cmd)
           print resp.read()
       resp.close()
       time.sleep(0.1) # keep from overflowing ESP wifi buffer
       cmd = stepperUrl+"stepper/stop"
       resp = urllib2.urlopen(cmd)
       if DEBUG:
           print (cmd)
           print resp.read()
       resp.close()
       time.sleep(0.1) # keep from overflowing ESP wifi buffer
    except:
       time.sleep(5)
       try:
           cmd = stepperUrl+"stepper/stop"
           resp = urllib2.urlopen(cmd)
           print (cmd)
           print resp.read()
           resp.close()
       except:
           print "Stepper comm failure"

eine doppelte exception auftritt. Die erste würde im except block landen und wenn dann auch der urllib2.urlopen(cmd) fehlschlägt
dann würde der Port wiederum auf HIGH stehen bleiben.
Man könnte zwar eine while schleifen einbauen, die müsste aber auch irgendwan abgrochen werden damit nicht das ganze Script
blockiert würde. Sowas im Sinne von

except:
    abort = 40
    while abort > 0:
        time.sleep(5)
        abort -= 5
        try:
            cmd = stepperUrl+"stepper/stop"
            resp = urllib2.urlopen(cmd)
            print (cmd)
            print resp.read()
            resp.close()
            break
        except:
            print "Stepper comm failure"

Sinnvoll wäre evtl auch den resp.read Wert zu prüfen ob tatsächlich Motor off kommt und nicht etwas anderes.

Cheers
Claudia

Für alle die mitlesen
Vorab: dies ist eine rein konzeptionelle Geschichte, heisst, natürlich
kann ich eine Klasse erstellen und diese nur einmal im kompletten
Program verwenden, nur ist dies dann keine wirkliche Singleton.
Es geht darum, dass ein Objekt nur einmal existiert und ich
dieses aus verschiedenen Codeteilen ansprechen kann und immer
mit der gleichen Instanz interagiere.

>Mit einem Singleton kann man ja etwas ähnliches wie eine globale Variable umsetzen.
Ja, korrekt, Singleton-Klassen sind von Natur aus im globalen Umfeld zu sehen
Eigentlich würde man ja als Pythonprogrammierer hergehen und dies ungefähr so angehen

class singleton_object(object):
    _instance = None
    test = 42


    def __new__(class_, *args, **kwargs):
        if not isinstance(class_._instance, class_):
            class_._instance = object.__new__(class_, *args, **kwargs)
        return class_._instance


    def __init__(self):
        pass


    def set(self,value):
        self.test = value

bei der Ausführung würde dass zum Beispiel so aussehen

>>> s = singleton_object()
>>> s.test
42
>>> s.set(21)
>>> s.test
21
>>> j = singleton_object()
>>> j.test
21
>>> j.set(34)
>>> s.test
34

Eigentlich alles ok, s und j liefern den gleichen Wert.
Kein Wunder, da beide ja das gleiche Objekt sind.
id(s)
3011504300L
id(j)
3011504300L

Aber was passiert wenn ich zum Beispiel die Klasse ableite?

class my_class(singleton_object):
    def __init__(self):
        pass

m = my_class()
m.test
42
id(m)
3011436076L

Oooppps - das war es mit der Singleton.
Hätte ich alles in einem Modul, mit einer Variable test und eine Funktion set die die globale Variable ändert,
dann kommt es zu so einem Problem gar nicht.

Es gibt noch weitere Ansätze wie über MetaClass etc... aber alle, so weit mir bekannt, habe irgendwo ein Problem
dass das Singleton-Konzept aushebelt.

Cheers
Claudia

Hi Don,

Du hattest ja schon mal angemerkt, dass der Motor anscheinend nur in eine Richtung dreht
aber nie mehr in die Ausgangsstellung zurück kommt. (hab ich so im Gedächtnis, sorry wenn ich
mich irre)
Hat sich da noch was ergeben in deinen Tests? Ist dem so?
Aktueller Code ist wo?

Zum Projekt, lustig wäre eine Parabolschüssel oben drauf, so wie bei SETI

Cheers
Claudia

Cheating - auf Ihn mit Gebrüll

und das def vor der Funktion

Cheers
Claudia

Der Hit, wäre ich nie auf die Idee gekommen das zu testen.

Cheers
Claudia

Zitat von DaVu

In allen Versionen, soweit mir bekannt.
Darauf habe ich sehr sehr weit vorn auch schon hingewiesen. Schade, dass du es nicht gelesen hast.

An die python cracks. Hilfe bei Minidisplay.

"
Ich glaube, was @BJ1
meinte war, dass es nicht gern gesehen ist, wenn man Variablen
innerhalb einer Funktion als globale Variable definiert. Wahrscheinlich
einfach aus Gründen der Lesbarkeit oder auch der Gefahr, dass eine zuvor
global gesetzt Variable überschrieben werden könnte."

Alles anzeigen

Hab ich gelesen, aber ich bezog mich auf sein letztes Code Beispiel.

Cheers
Claudia

@DaVu

Deutsch ist nicht meine Muttersprache aber war, bis dato, der Meinung das ich die ganz gut schreiben/sprechen
kann. Ist an dem Satz etwas falsch?

Variablen sind grundsätzlich implizit global, erst wenn eine Zuweisung erfolgt könnte aus einer globalen Variable
eine lokale werden.

>darauf habe ich ja weiter vorn auch schon hingewiesen, dass man mit "global <variable>" einen "äußeren" Wert >überschreibt. Sowas würde mir auch im Traum nicht einfallen

Ich hoffe Du kommst nie in die Verlegenheit eine Singleton-Klasse erstellen zu müssen, ansonsten könnte
Dir diese Aussage um die Ohren fliegen

Cheers
Claudia

@BJ1

Zitat von BJ1

Jetzt machen wir das Treiben richtig verrückt :

Code

x = 42


funk()
    x = 21
    print x
    global x     # jetzt wird das äussere x überschrieben


print x
funk()
print x


--> Ausgabe:


42
21
21

Alles anzeigen

In welcher Version? Ist das was Neues, dass dürfte nicht funktionieren.

Cheers
Claudia

@DaVu

Ich habe doch NIE gesagt das Variablen IMMER global sind, das ist natürlich mumpitz.
Ich habe gesagt das sie IMPLIZIT global sind und das deine Zuweisung sie EXPLIZIT zur lokalen
Variable machen. Wenn aber keine Zuweisung stattfindet sind sie globale Variablen.

Cheers
Claudia

Der NameError hat doch aber nichts mit unserer Diskussion zu tun, sondern diente nur der Klarstellung,
nämlich der das der Python Parser davon ausgegangen ist, dass y eine globale Varibale sein müsste,
das er diese dann aber nicht gefunden hat führte zur Exception.

Übrigens, ist das durchaus ein Mittel was benutzt wird, zum Beispiel um zu sehen ob Objekte
bereits initialisiert wurden oder nicht. Im Sinne von

try:
    x
except NameError:
    ... hier das was zu tun ist, wenn x noch nicht definiert ist.

Cheers
Claudia

Ich glaube jetzt weiß ich wo dein Mißverständnis ist, schau Dir mal folgendes an

def t():
    y
t()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "<input>", line 2, in t
NameError: global name 'y' is not defined

y ist nicht definiert und wo wurde es gesucht, im globals dictionary.

Durch deine Zuweisung von

y = 12

wurde aus einer implizit globalen Variable eine explizite lokale Variable.

Implizit heisst, dass wenn nicht explizit defniert wird eine globale Variable angenommen wird.
Die Zuweisung y = 12 innerhalb der Funktion ist eine explizite Anweisung eine lokale Variable zu
erstellen, WENN nicht vorher innerhalb der Funktion ein global explizit eine globale Variable definiert hatte.

Cheers
Claudia

>Variablen sind nicht 'grundsätzlich' implizit global.

Doch.

Mein Zitat:
Variablen sind grundsätzlich implizit global, erst wenn eine Zuweisung erfolgt könnte aus einer globalen Variable
eine lokale werden.

Solange eine Variable in einer Funktion keine Zuweisung bekommt, gibt es diese nicht im locals sondern nur
im globals. Damit ist sie wie BJ1 richtig sagt, implizit global, weil ja nirgends im Code explizit ein global gesetzt wurde.

Beispiel das hoffentlich auch zeigt warum und wo darauf zu achten ist:

x = 42


def t():
    print 'locals:{}'.format(locals())
    print 'globals:{}'.format(globals()['x'])


    print '\nZuweisung erfolgt\n'
    x = 12


    print 'locals:{}'.format(locals())
    print 'globals:{}'.format(globals()['x'])

Beim Aufruf von der Fuktion t wird folgendes ausgegeben

locals:{}
globals:42

Zuweisung erfolgt

locals:{'x': 12}
globals:42

Solange keine Zuweisung gemacht wurde existiert nur eine Variable x, nach der Zuweisung
existieren 2 Variablen x, eine lokale und eine globale.

Den Aufruf globals()['x'] habe ich gemacht, damit x gefiltert wurde, kann natürlich auch mit globals()
aufgerufen werden, dann bekommt man alle, zur Laufzeit bestehenden Objekte im globals zurückgeliefert.

Und das Beispiel zeigt hoffentlich auch warum das so wichtig ist. Greife ich in einer Funktion
auf eine Variable zu, die erst später in der Funktion, durch eine Zuweisung, lokal definiert wird, habe
ich wahrscheinlich ein unerwünschtes Verhalten.

Cheers
Claudia

Zitat von DaVu

Das würde ich so nicht unterschreiben:

Wie würdest Du dann erklären das eine Variable, die ausserhalb einer Funktion definiert wurde,
innerhalb der Funktion gelesen werden kann?
Wenn es stimmen würde, das alle Variablen innerhalb einer Funktion lokale Variablen sind, dann darfst Du dies nicht machen können

x=42


def test():
    print x

Es müsste ein Fehler beim Ausführen der Funktion test kommen, dass die Variable x keinen Wert hat oder nicht initialisiert ist.

Cheers
Claudia

Formatfehler klingt nach einem Mix aus Tabs und Spaces beim Einrücken.
Meine Beispiele habe ich immer mit Spaces gepostet. Du verwendest wahrscheinlich Tabs zu einrücken, oder?
Da ist Python ziemlich kleinlich aber verständlich da darüber ja der Codeblock erkannt wird.

Best practice - immer nur eine Variante wählen, entweder Tabs oder Spaces.
Textwrangler hat doch bestimmt eine Einstellung wo du das erzwingen kannst, oder?

Cheers
Claudia

Das funktioniert?
Wenn dann aber nicht aus den von Dir genannten Gründen.

Edit: verstehe, vermute das status = not status steht direkt innerhalb der while schleife und nicht in einer Funktion, ok,
dann braucht es aber das global status nicht.

Und darf ich frage wieso Du das mit dem

def status1():
    Code ....
    ....


status1()

machst? Was bringt Dir das? Wird die Funktion status1 noch des öfteren aus anderen Codeteilen aufgerufen?

Cheers
Claudia

Das ist genau die Fehlermeldung die Du bekommst wenn Du eine global Variable in einer Funktionen ändern willst - das Thema global Variable!
Also vor

status = not status

ein

global status

also

global status
status = not status

Wie das alles in deinem Code aussieht, kann ich nicht sagen ohne den zu sehen.
Aber generell gesagt ist es egal ob Du in der while not ... 5 Sekunden wartest oder innerhalb der Schleife ein 5 Sekunde Wartezeit hast.

Cheers
Claudia

@DaVu du bist ja gut, zitierst mein erstes Beispiel und änderst die wichtigste Stelle LOL

An globalen Variablen ist nichts magisches, man muß nur wissen, dass, sofern man den Code nicht 100%ig in eigener Hand hat,
sich der Wert dieser unvorgesehen ändern kann. Solange Du deinen Code bei Dir in deiner Umgebung laufen lässt, ist es raltiv sicher.
Voraussetzung natürlich, Du behandelst die globale Variable auch so wie vorgesehen.

@tjost
ich bin nicht wirklich tief in der Kodi Thematik drin, heisst ich schaue auch in die Doku.
Ich MEINE verstanden zu haben, dass z.B. über die Monitor Klasse Events abgefangen werden können welche
Dir den Hinweis geben was gerade bei Kodi passiert. Wenn Du mir kurz zusammenschreiben kannst, was Du
genau wann, wie haben willst, schaue ich mir das gerne heute Abend/Nacht an und gebe Dir Bescheid.

Bezgl. des aktuellen Problems

vor der while not xmbc.Monitor().waitForAbort Zeile fügst Du zum Beispiel eine Variable

status = False

ein.

In deinem Code würdest Du dann folgendes machen

if window=="10000":
    status = not status
    if status: # im Falle von True
        create_and_display_image(systemday, systemdate, font28)
    else: # im Falle von False
        create_and_display_image(systemtime, systemdate)

Keine sleeps innerhalb der if-Bedienung notwendig, da du bei jedem Schleifendurchlauf einen anderen Wert setzt.
Also,
initialer Wert von Status ist False
Erster Durchlauf
status = not status erzwingt das aus False nun True wird
damit wird if status ausgefüht-
Nächster Durchlauf, status ist immer noch auf den Wert True gesetzt,
erzwingt nun status = not status das der Wert wieder auf False gesetzt wird und daher nun
der else Teil ablaüft. Beim nächten wieder der if Teil und so weiter.

Wenn Du noch aus waitForAbort(2) ein waitForAbort(5) machst, hast Du deine 5 Sekunden Wartezeit.

Ginge das?

Cheers
Claudia

@DaVu
verstehe jetzt nicht ganz was Du meinst.
Variablen sind grundsätzlich implizit global, erst wenn eine Zuweisung erfolgt könnte aus einer globalen Variable
eine lokale werden.
Wenn ich auf Modulebene eine Variable definiere und diese dann in einer Funktion mit global referenziere dann
überschreibe ich diese nicht, sondern verweise darauf.

g_var = 0


def x():
    global g_var
    g_var = 1

g_var innerhalb von der Funktion x ist KEINE neue Variable, sondern g_var von vorher.

g_var = 0


def y():
    global neue_variable
    neue_variable = 1

Jetzt wird in der Funktion y eine neue Variable definiert und global gesetzt die vorher nicht bekannt war.
Das ist ein NoGo.

So, jetzt wird Essen gemacht.

Cheers
Claudia