Power aus Tabelle anhand der Umdrehungen an ANT+ senden.

[
 {
   "Level X RPM": 6,
   "20": 15,
   "30": 31,
   "40": 52,
   "50": 69,
   "60": 89,
   "70": 106,
   "80": 125,
   "90": 143
 },
 {
   "Level X RPM": 7,
   "20": 16,
   "30": 35,
   "40": 52,
   "50": 70,
   "60": 88,
   "70": 107,
   "80": 124,
   "90": 142
 },
 {
   "Level X RPM": 8,
   "20": 18,
   "30": 39,
   "40": 65,
   "50": 87,
   "60": 111,
   "70": 135,
   "80": 158,
   "90": 180
 }
]

#!/usr/bin/env python


# read_RPM.py
# 2016-01-20
# Public Domain


import time
import pigpio # http://abyz.co.uk/rpi/pigpio/python.html


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 read_RPM


   RPM_GPIO = 4
   RUN_TIME = 60.0
   SAMPLE_TIME = 2.0


   pi = pigpio.pi()


   p = read_RPM.reader(pi, RPM_GPIO)


   start = time.time()


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


      time.sleep(SAMPLE_TIME)


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


   p.cancel()


   pi.stop()

#!/usr/bin/python
import RPi.GPIO as GPIO
import time


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)
while True:
    input_state = GPIO.input(20)
    if input_state == False:
        print('Button + Pressed')
        time.sleep(0.8)
    input_state = GPIO.input(21)
    if input_state == False:
        print('Button - Pressed')
        time.sleep(0.8)

/// <summary>
/// Holds the conversion table for RPM and level to read the power in Watt.
/// </summary>
public static class PowerTable
{
const float MinRPM = 30f;
const float MaxRPM = 70f;


public const int RPMMaxCount = 4;  //4


/// <summary>
/// The power in Watt as [RPM][Level].
/// </summary>
static int [][] power = new int[RPMMaxCount][];


static PowerTable ()
{
// 40 RPM
power [0] = new int[LevelManager.LevelCount] {25, 34, 42, 51, 60, 69, 79, 88, 97, 106, 115, 123, 133, 142, 151, 160};
// 50 RPM
power [1] = new int[LevelManager.LevelCount] {38, 51, 64, 77, 91, 105, 119, 133, 146, 160, 174, 186, 200, 215, 228, 242};
// 60 RPM
power [2] = new int[LevelManager.LevelCount] {50, 69, 88, 107, 126, 145, 164, 183, 202, 221, 240, 259, 278, 297, 316, 335};
// 70 RPM
power [3] = new int[LevelManager.LevelCount] {69, 91, 114, 140, 163, 188, 214, 237, 263, 289, 312, 338, 361, 387, 409, 436};
        // 80 RPM
      //  power[4] = new int[LevelManager.LevelCount] {84, 91, 114, 140, 163, 188, 214, 237, 263, 289, 312, 338, 361, 387, 409, 436 };
        // power [0] [0] = 25;
    }


/// <summary>
/// Gets the power needed for the supplied RPM within the current level as defined in LevelManager.
/// </summary>
/// <returns>Power in Watt.</returns>
/// <param name="rpm">Rpm.</param>
public static int GetPower (float rpm)
{
int level = LevelManager.CurrentLevel;
if (level < 1 || level > LevelManager.LevelCount) {
return 0;
}
if (rpm >= MinRPM && rpm <= MaxRPM) {
int roundedIndex = Mathf.CeilToInt (rpm / 10f) - 4; //4
// let's stay on the safe side if Min and Max are configured far beyond the usual RPM range.
int i = Mathf.Clamp (roundedIndex, 0, RPMMaxCount);
return power[i][level - 1];
}
return 0;
}
}