1 #pragma once 2 3 #include <deque> 4 #include <tuple> 5 #include <vector> 6 7 namespace phosphor 8 { 9 namespace power 10 { 11 namespace history 12 { 13 14 static constexpr auto recIDPos = 0; 15 static constexpr auto recTimePos = 1; 16 static constexpr auto recAvgPos = 2; 17 static constexpr auto recMaxPos = 3; 18 using Record = std::tuple<size_t, int64_t, int64_t, int64_t>; 19 20 /** 21 * @class InvalidRecordException 22 * 23 * The exception that is thrown when a raw history record 24 * cannot be parsed. 25 */ 26 class InvalidRecordException : public std::runtime_error 27 { 28 public: 29 InvalidRecordException() : std::runtime_error("Invalid history record") 30 { 31 } 32 }; 33 34 /** 35 * @class RecordManager 36 * 37 * This class manages the records for the input power history of 38 * a power supply. 39 * 40 * The history is the average and maximum power values across 30s 41 * intervals. Every 30s, a new record will be available from the 42 * PS. This class takes that raw PS data and converts it into 43 * something usable by D-Bus. It ensures the readings are always 44 * sorted newest to oldest, and prunes out the oldest entries when 45 * necessary. If there is a problem with the ordering IDs coming 46 * from the PS, it will clear out the old records and start over. 47 */ 48 class RecordManager 49 { 50 public: 51 static constexpr auto RAW_RECORD_SIZE = 5; 52 static constexpr auto RAW_RECORD_ID_OFFSET = 0; 53 static constexpr auto FIRST_SEQUENCE_ID = 0; 54 static constexpr auto LAST_SEQUENCE_ID = 0xFF; 55 56 using DBusRecord = std::tuple<uint64_t, int64_t>; 57 using DBusRecordList = std::vector<DBusRecord>; 58 59 RecordManager() = delete; 60 ~RecordManager() = default; 61 RecordManager(const RecordManager&) = default; 62 RecordManager& operator=(const RecordManager&) = default; 63 RecordManager(RecordManager&&) = default; 64 RecordManager& operator=(RecordManager&&) = default; 65 66 /** 67 * @brief Constructor 68 * 69 * @param[in] maxRec - the maximum number of history 70 * records to keep at a time 71 */ 72 RecordManager(size_t maxRec) : RecordManager(maxRec, LAST_SEQUENCE_ID) 73 { 74 } 75 76 /** 77 * @brief Constructor 78 * 79 * @param[in] maxRec - the maximum number of history 80 * records to keep at a time 81 * @param[in] lastSequenceID - the last sequence ID the power supply 82 * will use before starting over 83 */ 84 RecordManager(size_t maxRec, size_t lastSequenceID) : 85 maxRecords(maxRec), lastSequenceID(lastSequenceID) 86 { 87 } 88 89 /** 90 * @brief Adds a new entry to the history 91 * 92 * Also checks to see if the old history should be 93 * cleared, such as when there is an invalid record 94 * sequence ID or if there was no data from the PS. 95 * 96 * @param[in] rawRecord - the record data straight 97 * from the power supply 98 * 99 * @return bool - If there has been a change to the 100 * history records that needs to be 101 * reflected in D-Bus. 102 */ 103 bool add(const std::vector<uint8_t>& rawRecord); 104 105 /** 106 * @brief Returns the history of average input power 107 * in a representation used by D-Bus. 108 * 109 * @return DBusRecordList - A list of averages with 110 * a timestamp for each entry. 111 */ 112 DBusRecordList getAverageRecords(); 113 114 /** 115 * @brief Returns the history of maximum input power 116 * in a representation used by D-Bus. 117 * 118 * @return DBusRecordList - A list of maximums with 119 * a timestamp for each entry. 120 */ 121 DBusRecordList getMaximumRecords(); 122 123 /** 124 * @brief Converts a Linear Format power number to an integer 125 * 126 * The PMBus spec describes a 2 byte Linear Format 127 * number that is composed of an exponent and mantissa 128 * in two's complement notation. 129 * 130 * Value = Mantissa * 2**Exponent 131 * 132 * @return int64_t the converted value 133 */ 134 static int64_t linearToInteger(uint16_t data); 135 136 /** 137 * @brief Returns the number of records 138 * 139 * @return size_t - the number of records 140 * 141 */ 142 inline size_t getNumRecords() const 143 { 144 return records.size(); 145 } 146 147 /** 148 * @brief Deletes all records 149 */ 150 inline void clear() 151 { 152 records.clear(); 153 } 154 155 private: 156 /** 157 * @brief returns the sequence ID from a raw history record 158 * 159 * Throws InvalidRecordException if the data is the wrong length. 160 * 161 * @param[in] data - the raw record data as the PS returns it 162 * 163 * @return size_t - the ID from byte 0 164 */ 165 size_t getRawRecordID(const std::vector<uint8_t>& data) const; 166 167 /** 168 * @brief Creates an instance of a Record from the raw PS data 169 * 170 * @param[in] data - the raw record data as the PS returns it 171 * 172 * @return Record - A filled in Record instance 173 */ 174 Record createRecord(const std::vector<uint8_t>& data); 175 176 /** 177 * @brief The maximum number of entries to keep in the history. 178 * 179 * When a new record is added, the oldest one will be removed. 180 */ 181 const size_t maxRecords; 182 183 /** 184 * @brief The last ID the power supply returns before rolling over 185 * back to the first ID of 0. 186 */ 187 const size_t lastSequenceID; 188 189 /** 190 * @brief The list of timestamp/average/maximum records. 191 * Newer records are added to the front, and older ones 192 * removed from the back. 193 */ 194 std::deque<Record> records; 195 }; 196 197 } // namespace history 198 } // namespace power 199 } // namespace phosphor 200