Posts by mobby

    Quote from Astorek86

    Was das Speichern angeht, ich würde das lieber auf einem externen USB-Stick machen. Flashmedien haben nur begrenzte Schreibzyklen, bei einem Defekt wär dann zumindest das System ansich in Ordnung...


    Und ein USB-Stick ist kein Flashmeidum? :denker:


    Quote from Astorek86

    Bei manchen Benutzern (z.B. auch bei mir) läuft der Raspberry Pi Modell B nicht über mehrere Tage/Wochen/Monate durch. In einem Skript würde ich den RPi alle 24 Stunden neustarten lassen. Oder Ähnliches^^...


    Bringt keinen Mehrwert, du kannst dein Pi auch Jahre durchgehend laufen lassen.

    Hey Leute,


    ich versuche gerade den CRC bei einem DS18B20-Temperatursensor durchzuführen, komme aber irgendwie nicht weiter. Ich verwende für Python das Modul crcmod. Der Doku kann man entnehmen, dass ich über die CRC function factory mit "mkCrcFun()" meine Funktion aufstellen kann, mit der sich der CRC berechnen lässt.


    Dem Datenblatt des SD18B20-Temperatursensor lässt sich entnehmen, dass das Generatorpolynom X^8 + X^5 + X^4 + 1 entspricht. Über das Polynom abgeleitet ergibt das bei mir 100110001 ... das sind aber 9-Bits und keine 8-Bits ... ? (Meine erste Verwirrung). Unabhängig von den 8- bzw. 9-Bits stehe ich mit meiner Python-Funktion vor einer Wand, denn betrachte ich die Doku, über das CRC-32 Beispiel, wird der poly-Wert mit Hex angegeben, in der Doku steht allerdings "a Python integer or long" ... ???


    Setzte ich mein Generatorpolynom ein, erhalte ich folgende Fehlermeldung: "The degree of the polynomial must be 8, 16, 24, 32 or 64". Irgendwie komisch.


    Stehe ich auf dem Schlauch, seh den Wald vor lauter Bäumen nicht oder was ist da los? Kann mir wer auf die Sprünge helfen? Big Thx!


    Ich hoffe, dass ich aber sonst korrekt in der Annahme bin, dass ich mit der Funktion, falls sie mein poly erkennen sollte, dann über .crc_function(data[, crc=initCRC]) mein CRC-Value berechnen kann.


    Der 64-Bit ROM-Code setzt sich ja aus 8-Bit "Family Code", 48-Bit "Seriennummer" und dem 8-Bit CRC zusammen. Nehme ich einen Beispiel-Senor mit der Kennung "28-000003cee4ca" handelt es sich dabei ja um Hex. Wandle ich das in Bits um, kommt n langer Rattenschwanz raus. Würde bei mir von LSB nach MSB "0001 0100 0101 0011 0010 0111 0111 0011 1100 0000 0000 0000 0000 0000 00000000" ergeben. Über das Polynom errechnet mir der Sensor daraus ja den bei mir ankommenden CRC, durch erneute Division über das Poly müsste dann ja bei perfekter Übertragung meine 8-Bits 0er rauskommen. Als "data" setze ich also den bei mir ankommenden Wert ein. Nur wo kann ich den entnehmen? Handelt es sich bei der oberen Zahlenreihe innerhalb der w1_slave-Datei dann um den mir übermittelten 64-Bit ROM-Code? Weil ich sehe da 18 Hex Werte, was 72-Bits entspricht und keine 64 ... *Verwirrung*


    Bin ich auf dem Holzweg? Hab das alles bisher nur in der Theorie gemacht, aber noch nie in der Praxis und auch nicht mit Python. Von daher vielen Dank um Nachsicht und ich hoffe, dass mir wer weiterhelefen kann.



    Gruß
    mobby

    cced: Du stimmt was vorne und hinten nicht. Schau dir diesen Thread an, da bin ich etwas auf das Thema eingegangen. Deinen Fehler siehst du dann schon selbst ;)


    //edit: @funnyzokcer: Haha hab ich mir auch erst gedacht mit den Augen, aber hast recht mit deiner Annahme, da fehlt was. ^^

    fuuman: Für deine Statusüberwachung erwähnst du doch schon alles was du brauchst. Eine Variable in dem der Status gespeichert wird. Dazu würde ich ein Flag setzen, also einen Boolean-Wert ("True" / "False"). Um das dann in der Schleife umzusetzen, kannst du innerhalb deines Zeitintervalls überprüfen, ob das Handy in Reichweite UND wie der Status des Flags ist. Wäre das Handy in Reichweite und der Flag auf "False", dann wird das Licht eingeschaltet sowie der Flag auf "True" gesetzt. Nächster Durchlauf: Ist das Handy in Reichweite und der Flag bereits auf "True", passiert nichts. Erst wenn dann das Handy außerhalb der Reichweite ist und der Flag noch auf "True" wird das Licht ausgeschaltet sowie der Flag auf "False" gesetzt. Das könnte so aussehen (ungetestet):



    Zum manuellen Schalten könntest du eine dritte If-Abfrage mit einer extra Status-Variable einfügen, aber das überlass ich jetzt mal dir ;)


    //edit: Hab mal noch dein os.system richtig gestellt.

    Düsentrieb: Also mal grundlegend, wenn du von Modulen sprichst, dann bedeutet das in Python, dass du Funktionen in eine andere Datei ausgelagert hast, Beispielsweise test.py.


    test.py:


    Code
    def function():
    variable = "test string"
    return variable


    In deinem Hauptskript wird dieses Modul dann geladen.


    Code
    import test
    test.function()


    Dabei überschreiben lokale Module die der Python-Bibliothek, bedeutet falls du aus versehen ein Modul gleichnamig abspeicherst wie ein Modul der Bibliothek, wird immer dein Modul geladen. Dabei sollten Modul + Hauptskript im gleichen Ordner liegen. Optimalst solltest du den Modulen also individuelle Namen geben, dann kann ein falscher Import ncht auftreten.


    Jetzt zu deinem Thema Variablen. Variablen werden wie bereits erwähnt immer mitgeschleift. Du kannst natürlich in deinem Hauptskript mit Variablen aus dem Modul arbeiten, musst sie aber einmal übergeben. Das haben wir ja schon erklärt. Sollte es dann dazu kommen, dass du von "allen Seiten" Variablen bearbeiten willst, brauchst du ein Objekt.


    So sieht ein einfaches Zähler-Objekt aus:



    Dieses Objekt erzeugst du so:


    Code
    counter = Counter()


    Dann hast du dein Objekt in der "Form" der Variable "counter". Dieses Objekt kannst du jetzt durch deine Komplettes Programm schleifen wie eine Variable. Und somit von überall ansprechen. Also z.b. einen Wert hochzählen mit.


    Code
    counter.increase()


    oder den Wert auslesen mit


    Code
    counter.read_value()


    Das nutzt man z.B., um mit Threads zu kommunizieren, sprich wenn du mehrere Prozesse parallel ablaufen lässt und sie miteinander kommunizieren sollen. Ich hoffe, dass dir das etwas geholfen hat. Bei weiteren Fragen schieß los.


    Und kobold254: Tut mir leid, das ich jetzt so direkt werden muss, aber hör bitte auf hier dein gefährliches Halbwissen zu verbreiten. Globale Variablen sollten, wie bootsmann gesagt hat, vermieten werden. Lass deine Kommentare lieber, wenn du nicht weißt von was du redest. Danke.

    Düsentrieb: Du musst die Variablen mitschleifen, so wie du das machst funktioniert natürlich nix.


    Code
    def first_function():
    variable_01 = "test"
    return variable_01
    print first_function()


    Oder:


    Der Fehler

    Quote

    IndentationError: expected an indented block

    hat nichts mit der Funktion zu tun, sondern damit, dass irgendwo ein Problem mit Tabs bzw. Leerzeichen besteht. Sprich du hast in deinem Code irgendwo damit gemischt, räum den auf dann sollte es gehen.


    Btw. Google gibt dir die Antwort auf den Fehler in 0,19 Sekunden ... kann doch echt nicht wahr sein ... :wallbash::wallbash::wallbash::wallbash:

    An kobold254 und oelkanne, ich kann mich da nur bootsmanns Meinung anschließen. Bitte geht doch erst mal das Python-Tutorial von vorne durch und versucht euch die Sprache richtig anzueignen. Diese Lösungen die ihr hier präsentiert mögen zwar im Moment funktionieren, aber spätestens wenn ihr weiter kommen wollt steht ihr wieder auf dem Schlauch. Zudem ist es so grausam programmiert, dass jeder Vorteil von Python umgedreht wird ... Es ist echt nicht böse gemeint, aber es wird euch selber viel weiter bringen, wenn ihr es erst richtig lernt, anstatt so ein hick hack zusammenzuwurschteln.

    Quote

    Hab mich ein bisschen mit NXPPY beschäftigt komme hier aber nicht weiter.


    Mit was kommst du nicht weiter und was sollen wir dazu sagen? Falls du einen allgemeinen Thread zum EXPLORE-NFC erföffnen möchtest, ist der Python-Bereich denke ich nicht dazu geeignet.

    Quote

    Zum Impulszählen kannst du eine globale Variable verwenden Icon_wink


    Bitte bloß keine globale Variable! Bau dir ein Objekt, mit dem du die Impulse zählen, auslesen usw. kannst.


    So z.B.:


    Quote

    Leider passen die Zeilenumbrüche dort sehr of nicht so dass ich alles in Python nachbearbeiten muss.


    Was meinst du damit? Falls du die Einrückung meinst, kannst du in den Optionen die Tabulatoren so einstellen, dass er automatisch 4 Leerzeichen setzt. Aber kp ob du das meinst.


    //edit: War wieder einer schneller hmpf

    Niklas3008: Wenn du von einem Knopf sprichst, was für einen Knopf meinst du dann? Den eines Aufsteckboards oder einen direkt über GPIOs angebunden Knopf?


    Unabhängig vom Knopf mal ein kleines Beispiel, wie man dein Problem angehen könnte.



    Jetzt ist es an dir die Sache mit Knöpfen zu verbinden. Ist nicht so komplex, wie du dir vielleicht denkst.

    Anses: Ich will mich mit der Meinung mal nicht zu weit aus dem Fenster lehnen, aber wäre es nicht geschickter, wenn du die Stromversorgung des Pi über die GPIOs anbindest anstatt über USB? Also rein von der Verkabelung doch viel simpler. Zudem umgehst du die Polyfuse und kannst deinem USB-Port mehr Saft liefern.