radio/src/telemetry/telemetry_holders.h

   1 /*
   2  * Copyright (C) OpenTX
   3  *
   4  * Based on code named
   5  *   th9x - http://code.google.com/p/th9x
   6  *   er9x - http://code.google.com/p/er9x
   7  *   gruvin9x - http://code.google.com/p/gruvin9x
   8  *
   9  * License GPLv2: http://www.gnu.org/licenses/gpl-2.0.html
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License version 2 as
  13  * published by the Free Software Foundation.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  */
  20
  21 #ifndef _TELEMETRY_HOLDERS_H_
  22 #define _TELEMETRY_HOLDERS_H_
  23
  24 #include <inttypes.h>
  25 #include "../timers.h"
  26
  27 #define TELEMETRY_AVERAGE_COUNT   3     // we actually average one more reading!
  28 #define RAW_FRSKY_MINMAX(v)       v.values[TELEMETRY_AVERAGE_COUNT-1]
  29
  30 class TelemetryValue {
  31   public:
  32     uint8_t value()
  33     {
  34       return _value;
  35     }
  36
  37     void set(uint8_t value)
  38     {
  39       _value = value;
  40     }
  41
  42     void reset()
  43     {
  44       set(0);
  45     }
  46
  47   protected:
  48     uint8_t _value;
  49 };
  50
  51 template <class T>
  52 class TelemetryFilterDecorator: public T {
  53   public:
  54     void set(uint8_t value)
  55     {
  56       if (value == 0 || this->_value == 0) {
  57         memset(values, value, TELEMETRY_AVERAGE_COUNT);
  58         this->_value = value;
  59       }
  60       else {
  61         // calculate the average from values[] and value
  62         // also shift readings in values [] array
  63         unsigned int sum = values[0];
  64         for (int i=0; i<TELEMETRY_AVERAGE_COUNT-1; i++) {
  65           uint8_t tmp = values[i+1];
  66           values[i] = tmp;
  67           sum += tmp;
  68         }
  69         values[TELEMETRY_AVERAGE_COUNT-1] = value;
  70         sum += value;
  71         this->_value = sum / (TELEMETRY_AVERAGE_COUNT+1);
  72       }
  73     }
  74
  75     void reset()
  76     {
  77       memclear(this, sizeof(*this));
  78     }
  79
  80   protected:
  81     uint8_t values[TELEMETRY_AVERAGE_COUNT];
  82 };
  83
  84 template <class T>
  85 class TelemetryExpiringDecorator: public T {
  86   public:
  87     void set(uint8_t value)
  88     {
  89       T::set(value);
  90       expirationTime = get_tmr10ms() + 1000/*10s*/;
  91     }
  92
  93     void reset()
  94     {
  95       memclear(this, sizeof(*this));
  96     }
  97
  98     bool isFresh()
  99     {
 100       return get_tmr10ms() < expirationTime;
 101     }
 102
 103   protected:
 104     tmr10ms_t expirationTime;
 105 };
 106
 107 template <class T>
 108 class TelemetryMinDecorator: public T {
 109   public:
 110     void set(uint8_t value)
 111     {
 112       T::set(value);
 113       if (!_min || value < _min) {
 114         _min = value;
 115       }
 116     }
 117
 118     uint8_t min()
 119     {
 120       return _min;
 121     }
 122
 123     void reset()
 124     {
 125       memclear(this, sizeof(*this));
 126     }
 127
 128   protected:
 129     uint8_t _min;
 130 };
 131
 132 #endif // _TELEMETRY_HOLDERS_H_