Werte aus Tabelle / Matrix / Array, oder Liste?

Python auf Einplatinencomputer wie Raspberry Pi, Banana Pi / Python für Micro-Controller
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

Ich bräuchte noch ein wenig Starthilfe :?

Aus meinen Werten ergeben sich Leistungsdaten:

Code: Alles auswählen

Level | RPM 20 30 40 50 60 70 80 90 100 110 120 130
------------------------------------------------------
6     |     15 31 52 75 105 135 166 202 231 275 289
7     |     16 35 58 85 118 152 185 226 260 305 332
8     |     18 39 65 96 131 169 208 249 289 333 375
Bei Level 6 und RPM > 60 < 70 Leistung = 105
Bei Level 6 und RPM > 70 < 80 Leistung = 135
Bei Level 7 und RPM > 60 < 70 Leistung = 118
usw.

Ich denke das geht auch einfacher, so das ich nicht alle Werte einzeln bestimmen muss.

Ich hab ja schon als Ausgabe Level und RPM
Nun muss ich ja Anhand der vorhanden Daten die Leistung angezeigt bekommen.

Was benutze ich dafür?
Ich denke ein Array ist dafür gut geeignet?

Beispiel:

Code: Alles auswählen

[
 {
   "Level": 6,
   "20": 15,
   "30": 31,
   "40": 52,
   "50": 69,
   "60": 89,
   "70": 106,
   "80": 125,
   "90": 143
 },
 {
   "Level": 7,
   "20": 16,
   "30": 35,
   "40": 52,
   "50": 70,
   "60": 88,
   "70": 107,
   "80": 124,
   "90": 142
 },
 {
   "Level": 8,
   "20": 18,
   "30": 39,
   "40": 65,
   "50": 87,
   "60": 111,
   "70": 135,
   "80": 158,
   "90": 180
 }
]
Wenn das Array so richtig ist, kann ich das ja schon fertig schreiben.
Sollte das Array in eine Extra Datei, damit es übersichtlich bleibt?
Ich könnte das ja mit:

Code: Alles auswählen

import powerarray.py
importieren.

Wie rufe ich jetzt aber die Daten passend zu Level und RPM ab?

Bis jetzt habe ich:

Code: Alles auswählen

   import time
   import pigpio
   import readRPM
   import RPi.GPIO as GPIO
   
   GPIO.setmode(GPIO.BCM)
   GPIO.setup(20, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   GPIO.setup(21, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   count = 5

   RPM_GPIO = 4
   RUN_TIME = 9600.0
   SAMPLE_TIME = 2.0

   pi = pigpio.pi()

   p = readRPM.reader(pi, RPM_GPIO)

   start = time.time()

   while (time.time() - start) < RUN_TIME:

    input_state = GPIO.input(20)
    if input_state == False:
        if count < 24:
         count = count + 1
         RPM = p.RPM()
         print('Level', count, 'RPM={}'.format(int(RPM+0.5)))
         time.sleep(SAMPLE_TIME)

    input_state = GPIO.input(21)
    if input_state == False:
       if count > 1:
        count = count - 1
        RPM = p.RPM()
        print('Level', count, 'RPM={}'.format(int(RPM+0.5)))
        time.sleep(SAMPLE_TIME)


    RPM = p.RPM()
    time.sleep(SAMPLE_TIME)
    print("RPM={}".format(int(RPM+0.5)))
Das funktioniert auch schon ganz gut :)
Benutzeravatar
Kebap
User
Beiträge: 686
Registriert: Dienstag 15. November 2011, 14:20
Wohnort: Dortmund

Als Datenstruktur innerhalb Python empfiehlt sich eine (geschachtelte) Liste oder Dictionary. Kannst du damit schon umgehen und so auf die einzelnen Elemente zugreifen?

Wenn du die Daten als Datei speichern willst, würde ich dir Json empfehlen. Ein "import" von reinen Daten als .py scheint eher unüblich.
MorgenGrauen: 1 Welt, 8 Rassen, 13 Gilden, >250 Abenteuer, >5000 Waffen & Rüstungen,
>7000 NPC, >16000 Räume, >200 freiwillige Programmierer, nur Text, viel Spaß, seit 1992.
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

Kebap hat geschrieben:Als Datenstruktur innerhalb Python empfiehlt sich eine (geschachtelte) Liste oder Dictionary. Kannst du damit schon umgehen und so auf die einzelnen Elemente zugreifen?
Kann ich nicht, aber deswegen bin ich ja hier :)

Also eine geschachtelte Liste wäre dann ja:

Code: Alles auswählen

Level6 = [15, 31, 52, 75, 105, 135, 166, 202, 231, 275, 289]
Level7 = [16, 35, 58, 85, 118, 152, 185, 226, 260, 305, 332]
Level8 = [18, 39, 65, 96, 131, 169, 208, 249, 289, 333, 375]
Wobei mir hier ja die RPM fehlen!?
Wenn du die Daten als Datei speichern willst, würde ich dir Json empfehlen. Ein "import" von reinen Daten als .py scheint eher unüblich.
Ich wollte nicht zwingend in einer Datei speichern. hauptsache ich raff später was ich da gemacht habe.
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

hmmm.. wenn ich jetzt ein Dictionary benutzen würde?

Code: Alles auswählen

Level6= [{'RPM': 20,  'Watt': '15'},  
              {'RPM': 30,  'Watt': '31'}]

Level7= ... nächste Liste
--
oder kann ich einfacher:

Code: Alles auswählen

Level6[20] = 15
Level6[20] = 31
usw. :K :?

Das erscheint mir alles ein wenig wirr!?
BlackJack

@Landixus: Du musst Dir klar machen welche Werte Du auf welche anderen Werte abbilden musst, damit man da sinnvoll und einfach drauf zugreifen kann. Und eventuell dann auch sinnvoll verschachtelt. Verschiedene `Level*`-Namen mit jeweils einer einfachen Liste daran gebunden sind beispielsweise keine verschachtelten Listen, sondern einfache Listen.

Man könnte beispielsweise eine Liste für die RPM-Werte verwenden und ein Wörterbuch das Level auf Listen mit Leistungswerten abbildet. Bei gegebenem Level- und RPM-Wert kann man dann erst den passenden Index in der RPM-Liste ermitteln, sich die Liste mit den Leistungen zum Level geben lassen, und dort dann per Index auf den gesuchten Leistungswert zugreifen. Genau so würde man manuell ja auch vorgehen wenn man die Tabelle auf einem Blatt Papier hätte.

Index für den RPM-Wert suchen geht übrigens mit dem `bisect`-Modul ganz gut.

Edit: Wobei man für die RPM-Werte keine Liste braucht → den Index kann man ja aus dem Wert einfach berechnen.

Edit2:

Code: Alles auswählen

RPM_LOWER_LIMIT = 20
LEVEL_TO_POWER = {
    6: [15, 31, 52, 75, 105, 135, 166, 202, 231, 275, 289],
    7: [16, 35, 58, 85, 118, 152, 185, 226, 260, 305, 332],
    8: [18, 39, 65, 96, 131, 169, 208, 249, 289, 333, 375],
}


def calculate_power(level, rounds_per_minute):
    # 
    # TODO Maybe handle too hight RPM values.
    # 
    if rounds_per_minute < RPM_LOWER_LIMIT:
        return 0
    return LEVEL_TO_POWER[level][(rounds_per_minute - RPM_LOWER_LIMIT) // 10]


def main():
    for level, rounds_per_minute in [(6, 65), (6, 71), (7, 68)]:
        print(calculate_power(level, rounds_per_minute))


if __name__ == '__main__':
    main()
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

BlackJack hat geschrieben:@Landixus: Du musst Dir klar machen welche Werte Du auf welche anderen Werte abbilden musst, damit man da sinnvoll und einfach drauf zugreifen kann. Und eventuell dann auch sinnvoll verschachtelt. Verschiedene `Level*`-Namen mit jeweils einer einfachen Liste daran gebunden sind beispielsweise keine verschachtelten Listen, sondern einfache Listen.
Einfach ist ja schon mal gut für mich. :) Ich nimm den Code unten mal auseinander damit ich das verstehe.
RPM_HIGH_LIMIT hinzugefügt.
Edit2:

Code: Alles auswählen

RPM_HIGH_LIMIT = 120
RPM_LOWER_LIMIT = 20
LEVEL_TO_POWER = {
    6: [15, 31, 52, 75, 105, 135, 166, 202, 231, 275, 289],
    7: [16, 35, 58, 85, 118, 152, 185, 226, 260, 305, 332],
    8: [18, 39, 65, 96, 131, 169, 208, 249, 289, 333, 375],
}
// LEVEL_TO_POWER ist meine "einfache Liste"

def calculate_power(level, rounds_per_minute): //berechne mit level und rounds_per_minute
    # 
    # TODO Maybe handle too hight RPM values.
    # 
    if rounds_per_minute < RPM_LOWER_LIMIT:  // Wenn RPM kleiner 20 = 0
    if rounds_per_minute > RPM_HIGH_LIMIT:  // Wenn RPM größer 120 = 0 // Wollen ja nicht cheaten :)
        return 0
    return LEVEL_TO_POWER[level][(rounds_per_minute - RPM_LOWER_LIMIT) // 10] sonst gebe zurück LEVEL_TO_POWER mit level und (rounds_per_minute -  RPM_LOWER_LIMIT)


def main():
    for level, rounds_per_minute in [(6, 65), (6, 71), (7, 68)]:  // Für level und rounds_per_minute in (Platzhalter Werte)?
        print(calculate_power(level, rounds_per_minute))  //dann Ausgabe der Berechnung


if __name__ == '__main__':
    main()

Ich hoffe ich hab das mal so richtig verstanden?
Ich versuche das mal einzubauen.
Danke schon mal für die Hilfe. :P

EDIT1:
Wobei ich ja nicht immer genau die RPM treffen werde, muss ich denn nicht noch haben wenn RPM >60<70 = 60? da so ja bei 62 nichts passieren würde!?
BlackJack

@Landixus: Wieso sollte bei 62 nichts passieren was bei 65, 71, und 68 im Beispiel ja eindeutig passiert. Du hast das ``// 10`` übersehen oder hältst ``//`` fälschlicherweise für einen Kommentar statt die ganzzahlige Division.
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

BlackJack hat geschrieben:@Landixus: Wieso sollte bei 62 nichts passieren was bei 65, 71, und 68 im Beispiel ja eindeutig passiert. Du hast das ``// 10`` übersehen oder hältst ``//`` fälschlicherweise für einen Kommentar statt die ganzzahlige Division.
Ja hab ich für ein Kommentar gehalten. :oops:
Ich habs mal eingebaut:
Kompletter Code "Bis jetzt":

Code: Alles auswählen

#!/usr/bin/env python
import time
import pigpio

class reader:
   """
   A class to read speedometer pulses and calculate the RPM.
   """
   def __init__(self, pi, gpio, pulses_per_rev=1.0, weighting=0.0, min_RPM=5.0):
      """
      Instantiate with the Pi and gpio of the RPM signal
      to monitor.

      Optionally the number of pulses for a complete revolution
      may be specified.  It defaults to 1.

      Optionally a weighting may be specified.  This is a number
      between 0 and 1 and indicates how much the old reading
      affects the new reading.  It defaults to 0 which means
      the old reading has no effect.  This may be used to
      smooth the data.

      Optionally the minimum RPM may be specified.  This is a
      number between 1 and 1000.  It defaults to 5.  An RPM
      less than the minimum RPM returns 0.0.
      """
      self.pi = pi
      self.gpio = gpio
      self.pulses_per_rev = pulses_per_rev

      if min_RPM > 1000.0:
         min_RPM = 1000.0
      elif min_RPM < 1.0:
         min_RPM = 1.0

      self.min_RPM = min_RPM

      self._watchdog = 200 # Milliseconds.

      if weighting < 0.0:
         weighting = 0.0
      elif weighting > 0.99:
         weighting = 0.99

      self._new = 1.0 - weighting # Weighting for new reading.
      self._old = weighting       # Weighting for old reading.

      self._high_tick = None
      self._period = None

      pi.set_mode(gpio, pigpio.INPUT)

      self._cb = pi.callback(gpio, pigpio.RISING_EDGE, self._cbf)
      pi.set_watchdog(gpio, self._watchdog)

   def _cbf(self, gpio, level, tick):

      if level == 1: # Rising edge.

         if self._high_tick is not None:
            t = pigpio.tickDiff(self._high_tick, tick)

            if self._period is not None:
               self._period = (self._old * self._period) + (self._new * t)
            else:
               self._period = t

         self._high_tick = tick

      elif level == 2: # Watchdog timeout.

         if self._period is not None:
            if self._period < 2000000000:
               self._period += (self._watchdog * 1000)

   def RPM(self):
      """
      Returns the RPM.
      """
      RPM = 0.0
      if self._period is not None:
         RPM = 60000000.0 / (self._period * self.pulses_per_rev)
         if RPM < self.min_RPM:
            RPM = 0.0

      return RPM

   def cancel(self):
      """
      Cancels the reader and releases resources.
      """
      self.pi.set_watchdog(self.gpio, 0) # cancel watchdog
      self._cb.cancel()

if __name__ == "__main__":

   import time
   import pigpio
   import readRPM
   import RPi.GPIO as GPIO

   GPIO.setmode(GPIO.BCM)
   GPIO.setup(20, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   GPIO.setup(21, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   count = 5

   RPM_GPIO = 4
   RUN_TIME = 9600.0
   SAMPLE_TIME = 2.0
   RPM_LOWER_LIMIT = 20
   RPM_HIGH_LIMIT = 120
   LEVEL_TO_POWER = {
       1: [6,12,20,29,40,53,69,79,92,106,121],
	2: [8,16,26,38,53,68,88,103,120,138,152],
	3: [9,20,32,47,66,84,107,125,148,172,186],
	4: [11,23,39,56,79,101,126,150,173,206,219],
	5: [13,27,45,65,92,117,145,175,202,238,254],
	6: [15,31,52,75,105,135,166,202,231,275,289],
        7: [16,35,58,85,118,152,185,226,260,305,332],
        8: [18,39,65,96,131,169,208,249,289,333,375],
	9: [19,42,71,104,144,184,227,272,318,361,408],
	10:[21,46,77,113,157,199,245,295,345,386,442],
	11:[23,50,84,123,170,216,262,318,372,413,480],
	12:[24,53,89,131,183,230,279,342,398,441,512],
	13:[26,56,94,139,196,245,296,365,424,468,548],
	14:[28,60,101,148,209,261,318,389,449,494,585],
	15:[30,64,108,158,222,277,337,415,476,518,620],
	16:[32,68,115,168,235,296,355,439,503,548,658],
	17:[33,72,122,177,248,312,373,463,530,576,694],
	18:[35,76,129,187,261,328,390,484,556,606,727],
	19:[37,79,134,195,274,342,407,507,572,632,763],
	20:[39,83,140,204,287,354,424,528,598,659,790],
	21:[40,87,146,213,300,368,442,551,616,689,812],
	22:[42,91,153,223,313,385,461,574,645,720,840],
	23:[44,95,160,234,326,401,479,598,673,752,872],
	24:[47,101,171,246,340,418,501,625,706,788,908],
    }

   pi = pigpio.pi()

   p = readRPM.reader(pi, RPM_GPIO)

   start = time.time()

   while (time.time() - start) < RUN_TIME:
	
    input_state = GPIO.input(20)
    if input_state == False:
        if count < 24:
         count = count + 1
         RPM = p.RPM()
	 print('Level', count, 'RPM={}'.format(int(RPM+0.5)))
         time.sleep(SAMPLE_TIME)
    
    input_state = GPIO.input(21)
    if input_state == False:
       if count > 1:
        count = count - 1
        RPM = p.RPM()
	print('Level', count, 'RPM={}'.format(int(RPM+0.5)))
        time.sleep(SAMPLE_TIME)


    RPM = p.RPM()
    time.sleep(SAMPLE_TIME) 
    print("RPM={}".format(int(RPM+0.5))) 
   
   p.cancel()
   pi.stop()

   def calculate_power(Level, rounds_per_minute):
    
    if rounds_per_minute > RPM_HIGH_LIMIT:
        return 0
    if rounds_per_minute < RPM_LOWER_LIMIT:
        return 0
    return LEVEL_TO_POWER[Level][(rounds_per_minute - RPM_LOWER_LIMIT) // 10]
 
 
   def main():
    for Level, rounds_per_minute in [(6, 65), (6, 71), (7, 68)]:
        print(calculate_power(Level, rounds_per_minute))
 
 
if __name__ == '__main__':
    main()
Wie ich schon erwartet habe, werde ich das nicht richtig eingebaut haben, da ich keine Powerausgabe bekomme.
Aber zumindest keine Fehlermeldung :) Und meine Liste ist komplett drinne :)
Da muss ich noch probieren...
Zuletzt geändert von Anonymous am Donnerstag 27. April 2017, 19:37, insgesamt 1-mal geändert.
Grund: Quelltext in Python-Codebox-Tags gesetzt.
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

So bin "glaube" ich bin etwas weiter gekommen:

Code: Alles auswählen

   import time
   import pigpio
   import readRPM
   import RPi.GPIO as GPIO
   
   GPIO.setmode(GPIO.BCM)
   GPIO.setup(20, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   GPIO.setup(21, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   count = 5

   RPM_GPIO = 4
   RUN_TIME = 9600.0
   SAMPLE_TIME = 2.0
   RPM_LOWER_LIMIT = 20
   RPM_HIGH_LIMIT = 120
   LEVEL_TO_POWER = {
    1: [6,12,20,29,40,53,69,79,92,106,121],
	2: [8,16,26,38,53,68,88,103,120,138,152],
	3: [9,20,32,47,66,84,107,125,148,172,186],
	4: [11,23,39,56,79,101,126,150,173,206,219],
    5: [13,27,45,65,92,117,145,175,202,238,254],
    6: [15,31,52,75,105,135,166,202,231,275,289],
    7: [16,35,58,85,118,152,185,226,260,305,332],
    8: [18,39,65,96,131,169,208,249,289,333,375],
	9: [19,42,71,104,144,184,227,272,318,361,408],
	10:[21,46,77,113,157,199,245,295,345,386,442],
	11:[23,50,84,123,170,216,262,318,372,413,480],
	12:[24,53,89,131,183,230,279,342,398,441,512],
	13:[26,56,94,139,196,245,296,365,424,468,548],
	14:[28,60,101,148,209,261,318,389,449,494,585],
	15:[30,64,108,158,222,277,337,415,476,518,620],
	16:[32,68,115,168,235,296,355,439,503,548,658],
	17:[33,72,122,177,248,312,373,463,530,576,694],
	18:[35,76,129,187,261,328,390,484,556,606,727],
	19:[37,79,134,195,274,342,407,507,572,632,763],
	20:[39,83,140,204,287,354,424,528,598,659,790],
	21:[40,87,146,213,300,368,442,551,616,689,812],
	22:[42,91,153,223,313,385,461,574,645,720,840],
	23:[44,95,160,234,326,401,479,598,673,752,872],
	24:[47,101,171,246,340,418,501,625,706,788,908],
    }

   pi = pigpio.pi()

   p = readRPM.reader(pi, RPM_GPIO)

def calculate_power(Level, RPM):
   start = time.time()
   while (time.time() - start) < RUN_TIME:
    input_state = GPIO.input(20)
    if input_state == False:
       	if count < 24:
          count = count + 1
          RPM = p.RPM()
	  print('Level', count, 'RPM={}'.format(int(RPM+0.5)))
          time.sleep(SAMPLE_TIME)
          return LEVEL_TO_POWER[Level][(RPM - RPM_LOWER_LIMIT) // 10]
	  for Level, RPM in [(6, 65), (6, 71), (7, 68)]:
       	   print(calculate_power(Level, RPM))
    
    
    input_state = GPIO.input(21)
    if input_state == False:
        if count > 1:
          count = count - 1
          RPM = p.RPM()
          print('Level', count, 'RPM={}'.format(int(RPM+0.5)))
          time.sleep(SAMPLE_TIME)
          return LEVEL_TO_POWER[Level][(RPM - RPM_LOWER_LIMIT) // 10]
          for Level, RPM in [(6, 65), (6, 71), (7, 68)]:
           print(calculate_power(Level, RPM))


    RPM = p.RPM()
    time.sleep(SAMPLE_TIME) 
    print("RPM={}".format(int(RPM+0.5))) 

   p.cancel()
   p.stop()   

def main():
    for Level, RPM in [(6, 65), (6, 71), (7, 68)]:
        print(calculate_power(Level, RPM))
 
 
if __name__ == '__main__':
    main()
Bekomme jetzt nach Aufruf des Programms:

Code: Alles auswählen

pi@carcam:~/AntOverPowerTable $ ./readRPM.py
RPM=0
RPM=0
RPM=0
RPM=0
RPM=0
RPM=300
RPM=50
RPM=19
RPM=2000000
RPM=98
RPM=23
Traceback (most recent call last):
  File "./readRPM.py", line 187, in <module>
    main()
  File "./readRPM.py", line 183, in main
    print(calculate_power(Level, RPM))
  File "./readRPM.py", line 152, in calculate_power
    if count < 24:
UnboundLocalError: local variable 'count' referenced before assignment
:(

Wenn ich den Level wechsel
Ich schlafe mal drüber gn8
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

Ich glaube ich versuche das nach der Arbeit noch mal so?:
[codebox=python file=Unbenannt.txt]def calculate_power(Level, RPM):
start = time.time()
while (time.time() - start) < RUN_TIME:
input_state = GPIO.input(20)
if input_state == False:
if count < 24:
count = count + 1
RPM = p.RPM()
print('Level', count, 'RPM={}'.format(int(RPM+0.5)))
time.sleep(SAMPLE_TIME)
return LEVEL_TO_POWER[Level][(RPM - RPM_LOWER_LIMIT) // 10]
for Level, RPM in [(6, 65), (6, 71), (7, 68)]:
print(calculate_power(Level, RPM))[/code]
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

Wo wir grad dabei sind, welchen Editor für Python mit Syntax-Erkennung ist auf der console nützlich?

Ich greif über putty auf meine PI3 zu und benutzte zur Zeit NANO als editor.
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

Na gut ich hab noch ne python Windows GUI zum syntax check, aber datt Programmens macht immer noch keine Powerausgabe :K

nochmal mein *code:

Code: Alles auswählen

#!/usr/bin/env python
import time
import pigpio
 
class reader:
   """
  A class to read speedometer pulses and calculate the RPM.
  """
   def __init__(self, pi, gpio, pulses_per_rev=1.0, weighting=0.0, min_RPM=5.0):
      """
     Instantiate with the Pi and gpio of the RPM signal
     to monitor.
 
     Optionally the number of pulses for a complete revolution
     may be specified.  It defaults to 1.
 
     Optionally a weighting may be specified.  This is a number
     between 0 and 1 and indicates how much the old reading
     affects the new reading.  It defaults to 0 which means
     the old reading has no effect.  This may be used to
     smooth the data.
 
     Optionally the minimum RPM may be specified.  This is a
     number between 1 and 1000.  It defaults to 5.  An RPM
     less than the minimum RPM returns 0.0.
     """
      self.pi = pi
      self.gpio = gpio
      self.pulses_per_rev = pulses_per_rev
 
      if min_RPM > 1000.0:
         min_RPM = 1000.0
      elif min_RPM < 1.0:
         min_RPM = 1.0
 
      self.min_RPM = min_RPM
 
      self._watchdog = 200 # Milliseconds.
 
      if weighting < 0.0:
         weighting = 0.0
      elif weighting > 0.99:
         weighting = 0.99
 
      self._new = 1.0 - weighting # Weighting for new reading.
      self._old = weighting       # Weighting for old reading.
 
      self._high_tick = None
      self._period = None
 
      pi.set_mode(gpio, pigpio.INPUT)
 
      self._cb = pi.callback(gpio, pigpio.RISING_EDGE, self._cbf)
      pi.set_watchdog(gpio, self._watchdog)
 
   def _cbf(self, gpio, level, tick):
 
      if level == 1: # Rising edge.
 
         if self._high_tick is not None:
            t = pigpio.tickDiff(self._high_tick, tick)
 
            if self._period is not None:
               self._period = (self._old * self._period) + (self._new * t)
            else:
               self._period = t
 
         self._high_tick = tick
 
      elif level == 2: # Watchdog timeout.
 
         if self._period is not None:
            if self._period < 2000000000:
               self._period += (self._watchdog * 1000)
 
   def RPM(self):
      """
     Returns the RPM.
     """
      RPM = 0.0
      if self._period is not None:
         RPM = 60000000.0 / (self._period * self.pulses_per_rev)
         if RPM < self.min_RPM:
            RPM = 0.0
 
      return RPM
 
   def cancel(self):
      """
     Cancels the reader and releases resources.
     """
      self.pi.set_watchdog(self.gpio, 0) # cancel watchdog
      self._cb.cancel()
 
if __name__ == "__main__":
 
   import time
   import pigpio
   import readRPM
   import RPi.GPIO as GPIO
 
   GPIO.setmode(GPIO.BCM)
   GPIO.setup(20, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   GPIO.setup(21, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   count = 5
 
   RPM_GPIO = 4
   RUN_TIME = 9600.0
   SAMPLE_TIME = 2.0
   RPM_LOWER_LIMIT = 20
   RPM_HIGH_LIMIT = 120
   LEVEL_TO_POWER = {
    1: [6,12,20,29,40,53,69,79,92,106,121],
    2: [8,16,26,38,53,68,88,103,120,138,152],
    3: [9,20,32,47,66,84,107,125,148,172,186],
    4: [11,23,39,56,79,101,126,150,173,206,219],
    5: [13,27,45,65,92,117,145,175,202,238,254],
    6: [15,31,52,75,105,135,166,202,231,275,289],
    7: [16,35,58,85,118,152,185,226,260,305,332],
    8: [18,39,65,96,131,169,208,249,289,333,375],
    9: [19,42,71,104,144,184,227,272,318,361,408],
    10:[21,46,77,113,157,199,245,295,345,386,442],
    11:[23,50,84,123,170,216,262,318,372,413,480],
    12:[24,53,89,131,183,230,279,342,398,441,512],
    13:[26,56,94,139,196,245,296,365,424,468,548],
    14:[28,60,101,148,209,261,318,389,449,494,585],
    15:[30,64,108,158,222,277,337,415,476,518,620],
    16:[32,68,115,168,235,296,355,439,503,548,658],
    17:[33,72,122,177,248,312,373,463,530,576,694],
    18:[35,76,129,187,261,328,390,484,556,606,727],
    19:[37,79,134,195,274,342,407,507,572,632,763],
    20:[39,83,140,204,287,354,424,528,598,659,790],
    21:[40,87,146,213,300,368,442,551,616,689,812],
    22:[42,91,153,223,313,385,461,574,645,720,840],
    23:[44,95,160,234,326,401,479,598,673,752,872],
    24:[47,101,171,246,340,418,501,625,706,788,908],
    }
 
   pi = pigpio.pi()
 
   p = readRPM.reader(pi, RPM_GPIO)
 
   start = time.time()
 
   while (time.time() - start) < RUN_TIME:
   
    input_state = GPIO.input(20)
    if input_state == False:
        if count < 24:
         count = count + 1
         RPM = p.RPM()
         print('Level', count, 'RPM={}'.format(int(RPM+0.5)))
         time.sleep(SAMPLE_TIME)
   
    input_state = GPIO.input(21)
    if input_state == False:
       if count > 1:
        count = count - 1
        RPM = p.RPM()
        print('Level', count, 'RPM={}'.format(int(RPM+0.5)))
        time.sleep(SAMPLE_TIME)
 
 
    RPM = p.RPM()
    time.sleep(SAMPLE_TIME)
    print("RPM={}".format(int(RPM+0.5)))
   
   p.cancel()
   pi.stop()
 
   def calculate_power(Level, RPM):
   
    if RPM > RPM_HIGH_LIMIT:
        return 0
    if RPM < RPM_LOWER_LIMIT:
        return 0
    return LEVEL_TO_POWER[Level][(RPM - RPM_LOWER_LIMIT) // 10]
 
 
   def main():
    for Level, RPM in [(6, 65), (6, 71), (7, 68)]:
        print(calculate_power(Level, RPM))
 
 
if __name__ == '__main__':
    main()
help, please
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

Irgendwie ist sowas wohl nix für mich.

Was ich viel weniger verstehe ist, ich biete für die komplette Aufgabe 100€ an, ok, das ist jetzt nicht der Hit, aber es meldet sich echt niemand darauf.
Entweder ist Geld im Moment nichts wert, oder ich hab was verpasst!?

Ich muss dann wohl weiter mit Brustgurt Power machen.
__deets__
User
Beiträge: 14480
Registriert: Mittwoch 14. Oktober 2015, 14:29

100€ kauft dir noch nicht mal 1.5h meiner Programmierzeit. Und das ist ein Stundensatz, den ich "einfach" verbuche - keine langwierige Abschätzung vorher & kein Risikoaufschlag. Da wären wir sonst deutlich unter einer Stunde.

Da dein Projekt bedingt durch die Komplexität mit IO und Benutzerfreundlichkeit durchaus ein paar Stunden mit viel hin und her in Abstimmung mit dir erwarten lässt - nein. Das ist nicht viel Geld für eine Individualentwicklung. Zumindest nicht vom Profi.

Wo hakt es denn? Ich finde so schlecht sieht dein Code nicht aus, da kann die Flinte noch mal aus dem Korn gebuddelt werden.
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

__deets__ hat geschrieben:
Wo hakt es denn? Ich finde so schlecht sieht dein Code nicht aus, da kann die Flinte noch mal aus dem Korn gebuddelt werden.
Ich hätte gerne: "Level, RPM und calculate_power" als Ausgabe

danach muss ich dann weiter sehen.
Ich weiß das ein "westlicher Programmierer teuer ist". Mehr hab ich halt nicht zur Verfügung leider.

Deswegen denke ich ja auch an den Allgemeinen nutzen des Programms :)
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

Auch mit drüber schreiben.... nix:

Code: Alles auswählen

   def calculate_power(Level, RPM):
   
    if RPM > RPM_HIGH_LIMIT:
        return 0
    if RPM < RPM_LOWER_LIMIT:
        return 0
    return LEVEL_TO_POWER[Level][(RPM - RPM_LOWER_LIMIT) // 10]
 
 
   def main():
    for Level, RPM in [(6, 65), (6, 71), (7, 68)]:
        print(calculate_power(Level, RPM))
        
   pi = pigpio.pi()
 
   p = readRPM.reader(pi, RPM_GPIO)
 
   start = time.time()
 
   while (time.time() - start) < RUN_TIME:
   
    input_state = GPIO.input(20)
    if input_state == False:
        if count < 24:
         count = count + 1
         RPM = p.RPM()
         print('Level', count, 'RPM={}'.format(int(RPM+0.5))(calculate_power(Level, RPM)))
         time.sleep(SAMPLE_TIME)
   
    input_state = GPIO.input(21)
    if input_state == False:
       if count > 1:
        count = count - 1
        RPM = p.RPM()
        print('Level', count, 'RPM={}'.format(int(RPM+0.5))(calculate_power(Level, RPM)))
        time.sleep(SAMPLE_TIME)
 
 
    RPM = p.RPM()
    time.sleep(SAMPLE_TIME)
    print("RPM={}".format(int(RPM+0.5)))
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

Code: Alles auswählen

pi@carcam:~/AntOverPowerTable $ ./5powerx.py
RPM=0
RPM=0
RPM=0
RPM=81
RPM=67
RPM=108
RPM=299
RPM=140
Traceback (most recent call last):
  File "./5powerx.py", line 172, in <module>
    print('Level', count, 'RPM={}'.format(int(RPM+0.5))(calculate_power(LEVEL, RPM)))
  File "./5powerx.py", line 142, in calculate_power
    return LEVEL_TO_POWER[LEVEL][(RPM - RPM_LOWER_LIMIT) //10]
TypeError: list indices must be integers, not float
aber meine Liste besteht doch aus Ganzzahlen!?

Code: Alles auswählen

 
   import time
   import pigpio
   import readRPM
   import RPi.GPIO as GPIO
 
   GPIO.setmode(GPIO.BCM)
   GPIO.setup(20, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   GPIO.setup(21, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   count = 5
 
   RPM_GPIO = 4
   RUN_TIME = 9600.0
   SAMPLE_TIME = 2.0
   RPM_LOWER_LIMIT = 20
   RPM_HIGH_LIMIT = 120
   LEVEL = count
   LEVEL_TO_POWER = {
    1: [6,12,20,29,40,53,69,79,92,106,121],
    2: [8,16,26,38,53,68,88,103,120,138,152],
    3: [9,20,32,47,66,84,107,125,148,172,186],
    4: [11,23,39,56,79,101,126,150,173,206,219],
    5: [13,27,45,65,92,117,145,175,202,238,254],
    6: [15,31,52,75,105,135,166,202,231,275,289],
    7: [16,35,58,85,118,152,185,226,260,305,332],
    8: [18,39,65,96,131,169,208,249,289,333,375],
    9: [19,42,71,104,144,184,227,272,318,361,408],
    10:[21,46,77,113,157,199,245,295,345,386,442],
    11:[23,50,84,123,170,216,262,318,372,413,480],
    12:[24,53,89,131,183,230,279,342,398,441,512],
    13:[26,56,94,139,196,245,296,365,424,468,548],
    14:[28,60,101,148,209,261,318,389,449,494,585],
    15:[30,64,108,158,222,277,337,415,476,518,620],
    16:[32,68,115,168,235,296,355,439,503,548,658],
    17:[33,72,122,177,248,312,373,463,530,576,694],
    18:[35,76,129,187,261,328,390,484,556,606,727],
    19:[37,79,134,195,274,342,407,507,572,632,763],
    20:[39,83,140,204,287,354,424,528,598,659,790],
    21:[40,87,146,213,300,368,442,551,616,689,812],
    22:[42,91,153,223,313,385,461,574,645,720,840],
    23:[44,95,160,234,326,401,479,598,673,752,872],
    24:[47,101,171,246,340,418,501,625,706,788,908],
    }
 
   def calculate_power(LEVEL, RPM):
   
        return LEVEL_TO_POWER[LEVEL][(RPM - RPM_LOWER_LIMIT) //10]
 
 
   def main():
    for LEVEL, RPM in [(6, 65), (6, 71), (7, 68)]:
        print(calculate_power(LEVEL, RPM))
           
   pi = pigpio.pi()
 
   p = readRPM.reader(pi, RPM_GPIO)
 
   start = time.time()
 
   while (time.time() - start) < RUN_TIME:
   
    input_state = GPIO.input(20)
    if input_state == False:
        if count < 24:
         count = count + 1
         RPM = p.RPM()
         LEVEL = count
         print('Level', count, 'RPM={}'.format(int(RPM+0.5))(calculate_power(LEVEL, RPM)))
         time.sleep(SAMPLE_TIME)
   
    input_state = GPIO.input(21)
    if input_state == False:
        if count > 1:
         count = count - 1
         RPM = p.RPM()
         LEVEL = count
         print('Level', count, 'RPM={}'.format(int(RPM+0.5))(calculate_power(LEVEL, RPM)))
         time.sleep(SAMPLE_TIME)
 
 
    RPM = p.RPM()
    time.sleep(SAMPLE_TIME)
    print("RPM={}".format(int(RPM+0.5)))
   
   p.cancel()
   pi.stop()
 

 
 
if __name__ == '__main__':
    main()
das voll doof
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

Also ist ja nicht so das ich am Tag der Arbeit faul rumsitze :)

Ich hab dann schon mal ein Ergebnis:

Code: Alles auswählen

#!/usr/bin/env python
import time
import pigpio
 
class reader:
   """
 A class to read speedometer pulses and calculate the RPM.
 """
   def __init__(self, pi, gpio, pulses_per_rev=1.0, weighting=0, min_RPM=5):
      """
    Instantiate with the Pi and gpio of the RPM signal
    to monitor.
 
    Optionally the number of pulses for a complete revolution
    may be specified.  It defaults to 1.
 
    Optionally a weighting may be specified.  This is a number
    between 0 and 1 and indicates how much the old reading
    affects the new reading.  It defaults to 0 which means
    the old reading has no effect.  This may be used to
    smooth the data.
 
    Optionally the minimum RPM may be specified.  This is a
    number between 1 and 1000.  It defaults to 5.  An RPM
    less than the minimum RPM returns 0.0.
    """
      self.pi = pi
      self.gpio = gpio
      self.pulses_per_rev = pulses_per_rev
 
      if min_RPM > 1000:
         min_RPM = 1000
      elif min_RPM < 1:
         min_RPM = 1
 
      self.min_RPM = min_RPM
 
      self._watchdog = 200 # Milliseconds.
 
      if weighting < 0:
         weighting = 0
      elif weighting > 0:
         weighting = 0
 
      self._new = 1 - weighting # Weighting for new reading.
      self._old = weighting       # Weighting for old reading.
 
      self._high_tick = None
      self._period = None
 
      pi.set_mode(gpio, pigpio.INPUT)
 
      self._cb = pi.callback(gpio, pigpio.RISING_EDGE, self._cbf)
      pi.set_watchdog(gpio, self._watchdog)
 
   def _cbf(self, gpio, level, tick):
 
      if level == 1: # Rising edge.
 
         if self._high_tick is not None:
            t = pigpio.tickDiff(self._high_tick, tick)
 
            if self._period is not None:
               self._period = (self._old * self._period) + (self._new * t)
            else:
               self._period = t
 
         self._high_tick = tick
 
      elif level == 2: # Watchdog timeout.
 
         if self._period is not None:
            if self._period < 2000000000:
               self._period += (self._watchdog * 1000)
 
   def RPM(self):
      """
    Returns the RPM.
    """
      RPM = 0
      if self._period is not None:
         RPM = 60000000 / (self._period * self.pulses_per_rev)
         if RPM < self.min_RPM:
            RPM = 0
 
      return RPM
 
   def cancel(self):
      """
    Cancels the reader and releases resources.
    """
      self.pi.set_watchdog(self.gpio, 0) # cancel watchdog
      self._cb.cancel()
 
if __name__ == "__main__":
 
   import time
   import pigpio
   import readRPM
   import RPi.GPIO as GPIO
 
   GPIO.setmode(GPIO.BCM)
   GPIO.setup(20, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   GPIO.setup(21, GPIO.IN, pull_up_down=GPIO.PUD_UP)
   count = 5
   RPM_GPIO = 4
   RUN_TIME = 9600.0
   SAMPLE_TIME = 2.0
   RPM_LOWER_LIMIT = 15
   RPM_HIGHER_LIMIT = 320
   LEVEL_TO_POWER = {
    1: [6,12,20,29,40,53,69,79,92,106,121],
    2: [8,16,26,38,53,68,88,103,120,138,152],
    3: [9,20,32,47,66,84,107,125,148,172,186],
    4: [11,23,39,56,79,101,126,150,173,206,219],
    5: [13,27,45,65,92,117,145,175,202,238,254],
    6: [15,31,52,75,105,135,166,202,231,275,289],
    7: [16,35,58,85,118,152,185,226,260,305,332],
    8: [18,39,65,96,131,169,208,249,289,333,375],
    9: [19,42,71,104,144,184,227,272,318,361,408],
    10:[21,46,77,113,157,199,245,295,345,386,442],
    11:[23,50,84,123,170,216,262,318,372,413,480],
    12:[24,53,89,131,183,230,279,342,398,441,512],
    13:[26,56,94,139,196,245,296,365,424,468,548],
    14:[28,60,101,148,209,261,318,389,449,494,585],
    15:[30,64,108,158,222,277,337,415,476,518,620],
    16:[32,68,115,168,235,296,355,439,503,548,658],
    17:[33,72,122,177,248,312,373,463,530,576,694],
    18:[35,76,129,187,261,328,390,484,556,606,727],
    19:[37,79,134,195,274,342,407,507,572,632,763],
    20:[39,83,140,204,287,354,424,528,598,659,790],
    21:[40,87,146,213,300,368,442,551,616,689,812],
    22:[42,91,153,223,313,385,461,574,645,720,840],
    23:[44,95,160,234,326,401,479,598,673,752,872],
    24:[47,101,171,246,340,418,501,625,706,788,908],
    }
 
   def calculate_power(LEVEL, RPM):
        
	if RPM < RPM_LOWER_LIMIT:
	 return 0
	return LEVEL_TO_POWER[LEVEL][(RPM - RPM_LOWER_LIMIT) //10]
	if RPM > RPM_HIGHER_LIMIT:
	 return 0
        return LEVEL_TO_POWER[LEVEL][(RPM + RPM_HIGHER_LIMIT) //10]
 
 
   def main():
    for LEVEL, RPM in [(1, 6), (2, 8), (3, 9)]:
     print(calculate_power(LEVEL, RPM))
   
   pi = pigpio.pi()
 
   p = readRPM.reader(pi, RPM_GPIO)
 
   start = time.time()
 
   while (time.time() - start) < RUN_TIME:
   
    input_state = GPIO.input(20)
    if input_state == False:
        if count < 24:
         count = count + 1
         RPM = (int(RPM+1))
	 LEVEL = count
         print('Power',calculate_power(LEVEL, RPM),'Level', count, 'RPM={}'.format(int(RPM+1)))
         print(calculate_power(LEVEL, RPM))
	 time.sleep(SAMPLE_TIME)
   
    input_state = GPIO.input(21)
    if input_state == False:
        if count > 1:
         count = count - 1
         RPM = (int(RPM+1))
	 LEVEL = count
         print('Power',calculate_power(LEVEL, RPM),'Level', count, 'RPM={}'.format(int(RPM+1)))
	 time.sleep(SAMPLE_TIME)
 
    
    LEVEL = count
    RPM = p.RPM()
    RPM = (int(RPM+1))
    time.sleep(SAMPLE_TIME)
    print('Power',calculate_power(LEVEL, RPM),'Level', count, "RPM={}".format(int(RPM+1)))    

   p.cancel()
   pi.stop()
 

 
 
if __name__ == '__main__':
    main()


Ich hab jetzt:

Code: Alles auswählen

('Power', 13, 'Level', 5, 'RPM=17')
('Power', 92, 'Level', 5, 'RPM=61')
('Power', 45, 'Level', 5, 'RPM=42')
('Power', 52, 'Level', 6, 'RPM=43')
als Ausgabe, aber bekomme noch ein Fehler obwohl ich ja begrenzt habe:

Code: Alles auswählen

Traceback (most recent call last):
  File "./5powerx.py", line 184, in <module>
    print('Power',calculate_power(LEVEL, RPM),'Level', count, "RPM={}".format(int(RPM+1)))
  File "./5powerx.py", line 142, in calculate_power
    return LEVEL_TO_POWER[LEVEL][(RPM - RPM_LOWER_LIMIT) //10]
IndexError: list index out of range
pi@carcam:~/AntOverPowerTable $
Wo habe ich hier denn noch den Fehler?
__deets__
User
Beiträge: 14480
Registriert: Mittwoch 14. Oktober 2015, 14:29

Nachdem ich mir dein Problem mal tiefer angeschaut habe muss ich sagen ich finde die Tabelle etwas seltsam. Es scheint als ob da RPM Bereiche auf einen Leistungswert abgebildet werden, statt ein RPM Wert auf einen Leistungswert.

Darum habe ich mir auch erstmal Interpolation gespart, denn das scheint gar nicht gewollt?

Hier mein Code zur Uebersezung von RPMs auf einen Leistungswert:

Code: Alles auswählen

import bisect

RPMS = [20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130,]

LEVEL_TO_POWER = {
    1: [6,12,20,29,40,53,69,79,92,106,121],
    2: [8,16,26,38,53,68,88,103,120,138,152],
    3: [9,20,32,47,66,84,107,125,148,172,186],
    4: [11,23,39,56,79,101,126,150,173,206,219],
    5: [13,27,45,65,92,117,145,175,202,238,254],
    6: [15,31,52,75,105,135,166,202,231,275,289],
    7: [16,35,58,85,118,152,185,226,260,305,332],
    8: [18,39,65,96,131,169,208,249,289,333,375],
    9: [19,42,71,104,144,184,227,272,318,361,408],
    10:[21,46,77,113,157,199,245,295,345,386,442],
    11:[23,50,84,123,170,216,262,318,372,413,480],
    12:[24,53,89,131,183,230,279,342,398,441,512],
    13:[26,56,94,139,196,245,296,365,424,468,548],
    14:[28,60,101,148,209,261,318,389,449,494,585],
    15:[30,64,108,158,222,277,337,415,476,518,620],
    16:[32,68,115,168,235,296,355,439,503,548,658],
    17:[33,72,122,177,248,312,373,463,530,576,694],
    18:[35,76,129,187,261,328,390,484,556,606,727],
    19:[37,79,134,195,274,342,407,507,572,632,763],
    20:[39,83,140,204,287,354,424,528,598,659,790],
    21:[40,87,146,213,300,368,442,551,616,689,812],
    22:[42,91,153,223,313,385,461,574,645,720,840],
    23:[44,95,160,234,326,401,479,598,673,752,872],
    24:[47,101,171,246,340,418,501,625,706,788,908],
    }

def clamp(v, lower, upper):
    return max(min(v, upper), lower)


def rpm2index(rpm):
    return clamp(bisect.bisect(RPMS, rpm) - 1, 0, len(RPMS) - 2)


def main():
    for rpm in xrange(20, 131):
        i = rpm2index(rpm)
        print(rpm, i, LEVEL_TO_POWER[1][i])


if __name__ == '__main__':
    main()
Bezueglich des "Allgemeinen nutzen des Programms" - der ist wohl eher nicht gegeben, ich bezweifele, dass diese Skript jemals woanders laufen wird. Und selbst wenn dem so sein sollte - das mag deine Motivation sein, anderen helfen zu wollen. Die von jemandem hier, der das Problem nicht hat, wird das wohl kaum sein. Sondern eher zu zeigen, wie man Probleme loest, oder was auch immer einen motiviert.
Benutzeravatar
Landixus
User
Beiträge: 49
Registriert: Mittwoch 26. April 2017, 09:38

__deets__ hat geschrieben:Nachdem ich mir dein Problem mal tiefer angeschaut habe muss ich sagen ich finde die Tabelle etwas seltsam. Es scheint als ob da RPM Bereiche auf einen Leistungswert abgebildet werden, statt ein RPM Wert auf einen Leistungswert.
Level + RPM = Leistungswert <-- eigentlich
Darum habe ich mir auch erstmal Interpolation gespart, denn das scheint gar nicht gewollt?
erm, doch schon, ich bettel hier ja nicht nach fertigem code und hab auch schon einige Stunden investiert.
Bezueglich des "Allgemeinen nutzen des Programms" - der ist wohl eher nicht gegeben, ich bezweifele, dass diese Skript jemals woanders laufen wird. Und selbst wenn dem so sein sollte - das mag deine Motivation sein, anderen helfen zu wollen. Die von jemandem hier, der das Problem nicht hat, wird das wohl kaum sein. Sondern eher zu zeigen, wie man Probleme loest, oder was auch immer einen motiviert.
Oh doch, ich möchte das schon so auf github aufbereiten, das es jeder der ein Gerät mit Powertabelle hat, entsprechend benutzen kann.
Ein paar zigtausend sind da schon auf dem Markt. Das gibt doch eine tolle Anleitung mit Raspberry PI :)

Die Tabelle ist ja der Anfang, danach muss der Wert ja noch übermittelt werden.
da bekomme ich vielleicht ein Inder für, die Arbeiten manchmal für 10$-15$ die Stunde.

Danke für den code, aber ich bin doch schon weit gekommen und scheitere nur noch an den "Limits"

Mir ist es schon wichtig, das es läuft wie ich mir das programmiert habe, das clamp sieht evtl. für mich interessant aus?

Aber trotzdem allen hier DANKE für die Hilfen, ihr seit sehr geduldig :)
Antworten