Hardware/Sensor.cs
author moel.mich
Sun, 01 May 2011 13:37:15 +0000
changeset 277 5c80f37c0330
parent 195 0ee888c485d5
child 298 96263190189a
permissions -rw-r--r--
Added first experimental support for the IT8728F super I/O chip.
     1 /*
     2   
     3   Version: MPL 1.1/GPL 2.0/LGPL 2.1
     4 
     5   The contents of this file are subject to the Mozilla Public License Version
     6   1.1 (the "License"); you may not use this file except in compliance with
     7   the License. You may obtain a copy of the License at
     8  
     9   http://www.mozilla.org/MPL/
    10 
    11   Software distributed under the License is distributed on an "AS IS" basis,
    12   WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
    13   for the specific language governing rights and limitations under the License.
    14 
    15   The Original Code is the Open Hardware Monitor code.
    16 
    17   The Initial Developer of the Original Code is 
    18   Michael Möller <m.moeller@gmx.ch>.
    19   Portions created by the Initial Developer are Copyright (C) 2009-2010
    20   the Initial Developer. All Rights Reserved.
    21 
    22   Contributor(s):
    23 
    24   Alternatively, the contents of this file may be used under the terms of
    25   either the GNU General Public License Version 2 or later (the "GPL"), or
    26   the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
    27   in which case the provisions of the GPL or the LGPL are applicable instead
    28   of those above. If you wish to allow use of your version of this file only
    29   under the terms of either the GPL or the LGPL, and not to allow others to
    30   use your version of this file under the terms of the MPL, indicate your
    31   decision by deleting the provisions above and replace them with the notice
    32   and other provisions required by the GPL or the LGPL. If you do not delete
    33   the provisions above, a recipient may use your version of this file under
    34   the terms of any one of the MPL, the GPL or the LGPL.
    35  
    36 */
    37 
    38 using System;
    39 using System.Collections.Generic;
    40 using System.Globalization;
    41 using OpenHardwareMonitor.Collections;
    42 
    43 namespace OpenHardwareMonitor.Hardware {
    44 
    45   internal class Sensor : ISensor {
    46 
    47     private readonly string defaultName;
    48     private string name;
    49     private readonly int index;
    50     private readonly bool defaultHidden;
    51     private readonly SensorType sensorType;
    52     private readonly IHardware hardware;
    53     private readonly ReadOnlyArray<IParameter> parameters;
    54     private float? currentValue;
    55     private float? minValue;
    56     private float? maxValue;
    57     private readonly Queue<SensorValue> values =
    58       new Queue<SensorValue>(MAX_MINUTES * 15);
    59     private readonly ISettings settings;
    60     private IControl control;
    61     
    62     private float sum;
    63     private int count;
    64 
    65     private const int MAX_MINUTES = 120;
    66    
    67     public Sensor(string name, int index, SensorType sensorType,
    68       IHardware hardware, ISettings settings) : 
    69       this(name, index, sensorType, hardware, null, settings) { }
    70 
    71     public Sensor(string name, int index, SensorType sensorType,
    72       IHardware hardware, ParameterDescription[] parameterDescriptions, 
    73       ISettings settings) :
    74       this(name, index, false, sensorType, hardware,
    75         parameterDescriptions, settings) { }
    76 
    77     public Sensor(string name, int index, bool defaultHidden, 
    78       SensorType sensorType, IHardware hardware, 
    79       ParameterDescription[] parameterDescriptions, ISettings settings) 
    80     {           
    81       this.index = index;
    82       this.defaultHidden = defaultHidden;
    83       this.sensorType = sensorType;
    84       this.hardware = hardware;
    85       Parameter[] parameters = new Parameter[parameterDescriptions == null ?
    86         0 : parameterDescriptions.Length];
    87       for (int i = 0; i < parameters.Length; i++ ) 
    88         parameters[i] = new Parameter(parameterDescriptions[i], this, settings);
    89       this.parameters = parameters;
    90 
    91       this.settings = settings;
    92       this.defaultName = name; 
    93       this.name = settings.GetValue(
    94         new Identifier(Identifier, "name").ToString(), name);
    95     }
    96 
    97     public IHardware Hardware {
    98       get { return hardware; }
    99     }
   100 
   101     public SensorType SensorType {
   102       get { return sensorType; }
   103     }
   104 
   105     public Identifier Identifier {
   106       get {
   107         return new Identifier(hardware.Identifier,
   108           sensorType.ToString().ToLowerInvariant(),
   109           index.ToString(CultureInfo.InvariantCulture));
   110       }
   111     }
   112 
   113     public string Name {
   114       get { 
   115         return name; 
   116       }
   117       set {
   118         if (!string.IsNullOrEmpty(value)) 
   119           name = value;          
   120         else 
   121           name = defaultName;
   122         settings.SetValue(new Identifier(Identifier, "name").ToString(), name);
   123       }
   124     }
   125 
   126     public int Index {
   127       get { return index; }
   128     }
   129 
   130     public bool IsDefaultHidden {
   131       get { return defaultHidden; }
   132     }
   133 
   134     public IReadOnlyArray<IParameter> Parameters {
   135       get { return parameters; }
   136     }
   137 
   138     public float? Value {
   139       get { 
   140         return currentValue; 
   141       }
   142       set {
   143         while (values.Count > 0 && 
   144           (DateTime.Now - values.Peek().Time).TotalMinutes > MAX_MINUTES)
   145           values.Dequeue();
   146 
   147         if (value.HasValue) {
   148           sum += value.Value;
   149           count++;
   150           if (count == 4) {
   151             values.Enqueue(new SensorValue(sum / count, DateTime.Now));
   152             sum = 0;
   153             count = 0;
   154           }
   155         }
   156 
   157         this.currentValue = value;
   158         if (minValue > value || !minValue.HasValue)
   159           minValue = value;
   160         if (maxValue < value || !maxValue.HasValue)
   161           maxValue = value;
   162       }
   163     }
   164 
   165     public float? Min { get { return minValue; } }
   166     public float? Max { get { return maxValue; } }
   167 
   168     public void ResetMin() {
   169       minValue = null;
   170     }
   171 
   172     public void ResetMax() {
   173       maxValue = null;
   174     }
   175 
   176     public IEnumerable<SensorValue> Values {
   177       get { return values; }
   178     }    
   179 
   180     public void Accept(IVisitor visitor) {
   181       if (visitor == null)
   182         throw new ArgumentNullException("visitor");
   183       visitor.VisitSensor(this);
   184     }
   185 
   186     public void Traverse(IVisitor visitor) {
   187       foreach (IParameter parameter in parameters)
   188         parameter.Accept(visitor);
   189     }
   190 
   191     public IControl Control {
   192       get {
   193         return control;
   194       }
   195       internal set {
   196         this.control = value;
   197       }
   198     }
   199   }
   200 }