1 #pragma once 2 3 #include "hwmonio.hpp" 4 #include "sensorset.hpp" 5 #include "types.hpp" 6 7 #include <chrono> 8 #include <gpioplus/handle.hpp> 9 #include <memory> 10 #include <unordered_set> 11 12 namespace sensor 13 { 14 15 struct valueAdjust 16 { 17 double gain = 1.0; 18 int offset = 0; 19 std::unordered_set<int> rmRCs; 20 }; 21 22 /** @class Sensor 23 * @brief Sensor object based on a SensorSet container's key type 24 * @details Sensor object to create and modify an associated device's sensor 25 * attributes based on the key type of each sensor in the set provided by the 26 * device. 27 */ 28 class Sensor 29 { 30 public: 31 Sensor() = delete; 32 Sensor(const Sensor&) = delete; 33 Sensor(Sensor&&) = default; 34 Sensor& operator=(const Sensor&) = delete; 35 Sensor& operator=(Sensor&&) = default; 36 ~Sensor() = default; 37 38 /** 39 * @brief Constructs Sensor object 40 * 41 * @param[in] sensor - A pair of sensor indentifiers 42 * @param[in] ioAccess - Hwmon sysfs access 43 * @param[in] devPath - Device sysfs path 44 */ 45 explicit Sensor(const SensorSet::key_type& sensor, 46 const hwmonio::HwmonIOInterface* ioAccess, 47 const std::string& devPath); 48 49 /** 50 * @brief Adds any sensor removal return codes for the sensor 51 * @details Add all return codes defined within a device's config file 52 * for the entire device or for the specific sensor. 53 * 54 * @param[in] rcList - List of return codes found for the sensor 55 */ 56 void addRemoveRCs(const std::string& rcList); 57 58 /** 59 * @brief Get the adjustments struct for the sensor 60 * 61 * @return - Sensor adjustment struct 62 */ 63 inline const valueAdjust& getAdjusts() const 64 { 65 return _sensorAdjusts; 66 } 67 68 /** 69 * @brief Adjusts a sensor value 70 * @details Adjusts the value given by any gain and/or offset defined 71 * for this sensor object and returns that adjusted value. 72 * 73 * @param[in] value - Value to be adjusted 74 * 75 * @return - Adjusted sensor value 76 */ 77 SensorValueType adjustValue(SensorValueType value); 78 79 /** 80 * @brief Add value interface and value property for sensor 81 * @details When a sensor has an associated input file, the Sensor.Value 82 * interface is added along with setting the Value property to the 83 * corresponding value found in the input file. 84 * 85 * @param[in] retryIO - Hwmon sysfs file retry constraints 86 * (number of and delay between) 87 * @param[in] info - Sensor object information 88 * 89 * @return - Shared pointer to the value object 90 */ 91 std::shared_ptr<ValueObject> addValue(const RetryIO& retryIO, 92 ObjectInfo& info); 93 94 /** 95 * @brief Add status interface and functional property for sensor 96 * @details OperationalStatus interface is added and the Functional property 97 * is set depending on whether a fault file exists and if it does it will 98 * also depend on the content of the fault file. _hasFaultFile will also be 99 * set to true if fault file exists. 100 * 101 * @param[in] info - Sensor object information 102 * 103 * @return - Shared pointer to the status object 104 */ 105 std::shared_ptr<StatusObject> addStatus(ObjectInfo& info); 106 107 /** 108 * @brief Get the scale from the sensor. 109 * 110 * @return - Scale value 111 */ 112 inline int64_t getScale(void) const 113 { 114 return _scale; 115 } 116 117 /** 118 * @brief Get the GPIO handle from the sensor. 119 * 120 * @return - Pointer to the GPIO handle interface, can be nullptr. 121 */ 122 inline const gpioplus::HandleInterface* getGpio(void) const 123 { 124 return _handle.get(); 125 } 126 127 /** 128 * @brief Get whether the sensor has a fault file or not. 129 * 130 * @return - Boolean on whether the sensor has a fault file 131 */ 132 inline bool hasFaultFile(void) const 133 { 134 return _hasFaultFile; 135 } 136 137 private: 138 /** @brief Sensor object's identifiers */ 139 SensorSet::key_type _sensor; 140 141 /** @brief Hwmon sysfs access. */ 142 const hwmonio::HwmonIOInterface* _ioAccess; 143 144 /** @brief Physical device sysfs path. */ 145 const std::string& _devPath; 146 147 /** @brief Structure for storing sensor adjustments */ 148 valueAdjust _sensorAdjusts; 149 150 /** @brief Optional pointer to GPIO handle. */ 151 std::unique_ptr<gpioplus::HandleInterface> _handle; 152 153 /** @brief sensor scale from configuration. */ 154 int64_t _scale; 155 156 /** @brief Tracks whether the sensor has a fault file or not. */ 157 bool _hasFaultFile; 158 }; 159 160 /** @class GpioLock 161 * @brief RAII class for GPIO unlock and lock 162 * @details Create this object in the stack to unlock the GPIO. GPIO will 163 * be locked by the destructor when we go out of scope. 164 */ 165 class GpioLock 166 { 167 public: 168 GpioLock() = delete; 169 GpioLock(const GpioLock&) = delete; 170 GpioLock(GpioLock&&) = default; 171 GpioLock& operator=(const GpioLock&) = delete; 172 GpioLock& operator=(GpioLock&&) = default; 173 174 /** 175 * @brief Constructs GpioLock RAII object. Unlocks the GPIO. 176 * 177 * @param[in] handle - Pointer to a GPIO handle interface, can be nullptr. 178 */ 179 explicit GpioLock(const gpioplus::HandleInterface* handle); 180 181 /** 182 * @brief Destructs GpioLock RAII object. Locks the GPIO. 183 */ 184 ~GpioLock(); 185 186 /** 187 * @brief Unlock the gpio, set to high if relevant. 188 */ 189 void unlockGpio(); 190 191 /** 192 * @brief Lock the gpio, set to low if relevant. 193 */ 194 void lockGpio(); 195 196 private: 197 /** @brief Pointer to GPIO handle. */ 198 const gpioplus::HandleInterface* _handle; 199 200 /** @brief default pause after unlocking gpio. */ 201 static constexpr std::chrono::milliseconds _pause{500}; 202 }; 203 204 } // namespace sensor 205