saal 0.2.2 → 0.2.11

data/TODO

@@ -1,11 +1,15 @@
 TODO
+!-Index the value column of the sensor reads for minimum and maximum
+- Change the filtering operations (e.g., outliercache) so that the raw value is always stored in the database
+- Make the outliercache filter based on the expected sensor range (e.g. -20-50 in temperature and 800-1200 in pressure) so as to not be overly sensitive when around 0)
 - Add logging to the daemon
 ?- Change the sensor configuration to be a ruby DSL and make it a daemon config
 - Split classes into one per file with corresponding test (rails style)
 - Verify inputs on the server to make sure it never crashes
 - Remove the chart configuration options from the saal_chart script
+?- Remove Sensors and Charts and move their functionality to Sensor and Chart
 - Add an init.d file to the package (and possibly an installer script for ubuntu/debian)
-- Add outlier detection and removal
+- Add interface that does retries for reading as well as writing (e.g., dinrelay confirm state change)
 DONE
 X- Make the server bind only to a certain interface (not applicable)
 X- Override OWNet::Connection with a mock object so that owserver is not needed
@@ -22,3 +26,5 @@ X- Make connections persistant
 - Make the date returned by GET the date of the last read (GET doesn't return
   a date now
 - Implement monthly, yearly and 10-day average charts
+- Add outlier detection and removal
+- Add filter support to sensor reads (e.g., altitude compensation for pressure)

data/bin/saal_chart

@@ -1,110 +1,84 @@
 #!/usr/bin/env ruby
+NUM_VALUES = 500 # Number of datapoints per series in the chart
 
 require File.dirname(__FILE__)+'/../lib/saal.rb'
 
 def usage
-  $stderr.puts("Usage: saal_chart <day|week|4week|year|4year> <chart_file.png>")
+  $stderr.puts("Usage: saal_chart <chart dir>")
 end
 
-if ARGV.size != 2
+if ARGV.size != 1
   usage
   exit (2)
 end
 
-@now = Time.now.utc
-
-NUM_VALUES = 500
-case ARGV[0]
-when 'day' then
-  PERIODNAMES = (0..23).map{|i| ((@now.hour - i)%24).to_s}.reverse
-  ALIGNMENT = :hour 
-  NUMDAYS = 1
-  ALIGNNAMES = :center
-when 'week' then
-  daynames = ["Seg","Ter","Qua","Qui","Sex","Sab","Dom"]
-  PERIODNAMES = (1..7).map{|i| (@now.wday - i)%7}.map{|w| daynames[w]}.reverse
-  ALIGNMENT = :day 
-  NUMDAYS = 7
-  ALIGNNAMES = :center
-when '4week' then
-  monthnames = ["Jan","Fev","Mar","Abr","Mai","Jun","Jul","Ago","Sep","Out","Nov","Dez"]
-  initial = @now.to_i - (@now.wday-1)*24*60*60
-  PERIODNAMES = (0...4).map do |i| 
-    time = Time.at(initial - i*24*60*60*7)
-    time.day.to_s+" "+ monthnames[time.month-1]
-  end.reverse
-  ALIGNMENT = :week
-  NUMDAYS = 28
-  ALIGNNAMES = :left
-when 'year' then
-  monthnames = ["Jan","Fev","Mar","Abr","Mai","Jun","Jul","Ago","Sep","Out","Nov","Dez"]
-  initial = @now.to_i - (@now.wday-1)*24*60*60
-  PERIODNAMES = (1..12).map{|i| (@now.month - i)%12}.map{|m| monthnames[m]}.reverse
-  ALIGNMENT = :month
-  NUMDAYS = 356
-  ALIGNNAMES = :center
-when '4year' then
-  PERIODNAMES = (0..3).map{|i| (@now.year - i).to_s}.reverse
-  ALIGNMENT = :year
-  NUMDAYS = 356*3
-  ALIGNNAMES = :center
-else
-  usage
-  exit(3)
-end
-NUMPERIODS = PERIODNAMES.size
-
-align = {:year => [12,31,23,59,59],
-         :month => [31,23,59,59],
-         :day => [23,59,59],
-         :week => [23,59,59],
-         :hour => [59,59]}
-
-args = [@now.year, @now.month, @now.day, @now.hour, @now.min, @now.sec]
-args = args[0..-(align[ALIGNMENT].size+1)]
-args += align[ALIGNMENT]
-@to = Time.utc(*args).to_i
-@to += (6-@now.wday)*60*60*24 if ALIGNMENT == :week
-@from = @to - 60*60*24*NUMDAYS
-
-@sensors = SAAL::Sensors.new
-def create_data(sensor, min, max, constant=0)
-  @c = SAAL::ChartData.new(@sensors.send(sensor))
-  d = @c.get_data(@from, @to, NUM_VALUES)
-  d = d.map{|num| num ? num+constant : num}
-  @c.normalize_data(d,min,max)
-end
-
-@data = [create_data('temp_exterior', -15, 45),
-         create_data('temp_estufa', -15, 45),
-         create_data('hum_exterior', 0, 100),
-         create_data('pressao', 950, 1050, 0.54*33.86)] #Convert to pressure at sea level
-
-
-@dataurl = @data.map {|values| values.join(",")}.join('|')
-
-r = {}
-case ALIGNNAMES
-when :center
-  @periodnamesurl = "||"+PERIODNAMES.join('||')+"||"
-when :left
-  @periodnamesurl = "|"+PERIODNAMES.join('|')+"||"
-  r[:chxs] = "0,555555,11,-1,lt"
+SENSORS = [[:temp_exterior, [-15, 45]], [:temp_estufa, [-15, 45]],
+           [:hum_exterior, [0,100]], 
+           [:pressao, [950,1050]]]
+
+
+SAAL::Charts.new.each do |chart|
+  $stderr.puts "Generating chart #{chart.name}"
+
+  pngfile = ARGV[0]+'/chart-'+chart.name.to_s+'.png'
+  ymlfile = ARGV[0]+'/chart-'+chart.name.to_s+'.yml'
+
+  @mins = chart.minimum
+  @maxs = chart.maximum
+  @avgs = chart.average
+  @minmax = {}
+  SENSORS.each do |s,r| 
+    @minmax[s] = {:maximum => @maxs[s], :minimum => @mins[s], :average => @avgs[s]}
+  end
+
+  File.open(ymlfile, 'w').write(YAML::dump(@minmax))
+
+  def normalize_data(data, min, max, offset=0)
+    data.map do |i|
+      if i.nil?
+        -1.0
+      elsif i < min
+        0.0
+      elsif i > max
+        100.0
+      else
+        (((i-min)/(max-min).to_f)*1000).round/10.0+offset
+      end
+    end
+  end
+
+  @periodnames = chart.periodnames
+  @numperiods = @periodnames.size
+  @averages = chart.average(NUM_VALUES)
+
+  @data = SENSORS.map do |sensor, range|
+    normalize_data(@averages[sensor], *range)
+  end
+
+  @dataurl = @data.map {|values| values.join(",")}.join('|')
+
+  r = {}
+  case chart.alignlabels
+  when :center
+    @periodnamesurl = "||"+@periodnames.join('||')+"||"
+  when :left
+    @periodnamesurl = "|"+@periodnames.join('|')+"||"
+    r[:chxs] = "0,555555,11,-1,lt"
+  end
+  @xincr = 100.0/@numperiods.to_f*10000.truncate.to_f/10000
+
+  r[:chof] = "png"
+  r[:chs] = "700x300"
+  r[:cht] = "lc"
+  r[:chco] = "00ff00,ff0000,0000ff,ffff00"
+  r[:chxt] = "x,y,y,r"
+  r[:chxl] = "0:#{@periodnamesurl}1:|-15ºC||0||15||30||45ºC|2:|0%|25|50|75|100%|3:|950||975||1000||1025||1050 hPa"
+  r[:chg] = "#{@xincr},12.5,1,5"
+  r[:chd] = "t:#{@dataurl}"
+
+  @url = "http://chart.apis.google.com/chart?&"
+  @postdata = r.map{|k,v| k.to_s+"="+v}.join("&")
+
+
+  system "wget --quiet \"#{@url}\" --post-data=\"#{@postdata}\" -O #{pngfile}"
 end
-@xincr = 100.0/NUMPERIODS.to_f*10000.truncate.to_f/10000
-
-r[:chof] = "png"
-r[:chs] = "700x300"
-r[:cht] = "lc"
-r[:chco] = "00ff00,ff0000,0000ff,ffff00"
-r[:chxt] = "x,y,y,r"
-r[:chxl] = "0:#{@periodnamesurl}1:|-15ºC||0||15||30||45ºC|2:|0%|25|50|75|100%|3:|950||975||1000||1025||1050 hPa"
-r[:chg] = "#{@xincr},12.5,1,5"
-r[:chd] = "t:#{@dataurl}"
-
-@url = "http://chart.apis.google.com/chart?&"
-@postdata = r.map{|k,v| k.to_s+"="+v}.join("&")
-
-
-system "wget --quiet \"#{@url}\" --post-data=\"#{@postdata}\" -O #{ARGV[1]}"
-

data/bin/saal_daemon

@@ -6,17 +6,25 @@ SENSORSCONF = "/etc/saal/sensors.yml"
 
 require File.dirname(__FILE__)+'/../lib/saal.rb'
 
+def usage
+  $stderr.puts "Usage: saal_daemon <pidfile|--foreground>"
+end
+
 if ARGV.size != 1
-  $stderr.puts "Usage: saal_daemon [pidfile]"
+  usage
   exit 2
 else
-  pidfile = ARGV[0]  
+  pidfile = ARGV[0]
+  foreground = (ARGV[0] == '--foreground')
   d = SAAL::Daemon.new(:interval => SENSOR_INTERVAL,
                        :sensorconf => SENSORSCONF,
-                       :dbconf => DBCONF)
+                       :dbconf => DBCONF,
+                       :foreground => foreground)
   pid = d.run
-  File.open(pidfile, 'w') do |f|
-    f.write(pid)
-    f.close
+  if !foreground
+    File.open(pidfile, 'w') do |f|
+      f.write(pid)
+      f.close
+    end
   end
 end

data/lib/chart.rb

@@ -0,0 +1,50 @@
+module SAAL
+  class Chart
+    attr_reader :name, :num, :periods, :alt, :description, :sensors, :alignlabels
+    def initialize(name, defs, sensors, opts={})
+      @name = name
+      @defs = defs
+      @alignlabels = (defs['alignlabels'] || :center).to_sym
+      @sensors = defs['sensors'].map{|name| sensors.send(name)} 
+      @num = defs['last']
+      @periods = defs['periods']
+      @alt = defs['alt']
+      @description = defs['description']
+      @datarange = ChartDataRange.new(defs.merge(:now => opts[:now]))
+    end
+
+    def periodnames
+      @datarange.periodnames
+    end
+
+    def average(num=nil)
+      get_data(:average, num)
+    end
+
+    def minimum(num=nil)
+      get_data(:minimum, num)
+    end
+
+    def maximum(num=nil)
+      get_data(:maximum, num)
+    end
+
+    def from
+      @datarange.from
+    end
+    def to
+      @datarange.to
+    end
+
+    private
+    def get_data(method, num)
+      n = num || 1
+      h = {}
+      @sensors.each do |s| 
+        data = @datarange.get_data(method,s,n)
+        h[s.name.to_sym] = num ? data : data[0]
+      end
+      h
+    end
+  end
+end

data/lib/chart_data.rb

@@ -1,30 +1,114 @@
 module SAAL
-  class ChartData
-    def initialize(sensor)
-      @sensor = sensor
+  class ChartDataRange
+    ALIGN = {:years => [12,31,23,59,59],
+             :months => [31,23,59,59],
+             :days => [23,59,59],
+             :weeks => [23,59,59],
+             :hours => [59,59]}
+
+    NUMHOURS = {:hours => 1, :days => 24, :weeks => 24*7}
+    DAYNAMES = ["Mon","Tue","Wed","Thu","Fri","Sat","Sun"]
+    MONTHNAMES = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]
+
+    attr_reader :num, :periods
+    def initialize(opts={})
+      last = opts[:last] || opts['last'].to_i
+      periods = opts[:periods] || (opts['periods'] ? opts['periods'].to_sym : nil)
+      @now = opts[:now] || Time.now.utc
+      if last && periods
+        @num = last
+        @periods = periods
+        calc_alignment
+      else
+        @from = opts[:from] || 0
+        @to = opts[:to] || @now
+      end
+    end
+
+    def from
+      @from.to_i
     end
-    
-    def get_data(from, to, num)
-      step = (to - from).to_f/num.to_f
+
+    def to
+      @to.to_i
+    end
+
+    def get_data(method, sensor, num)
+      step = (@to - @from).to_i/num
+      t = @from - 1
       (0..num-2).map do |i|
-        f = (from+i*step).to_i
-        t = (from+(i+1)*step-0.5).to_i
-        @sensor.average(f, t)
-      end << @sensor.average((from+(num-1)*step).to_i, to)
+        f = t + 1
+        t = (f+step)
+        v = sensor.send(method, f.to_i, t.to_i)
+      end << sensor.send(method, (t+1).to_i, to.to_i)
+    end
+
+    def periodnames
+      if !@num
+        raise RuntimeError, 
+              "Trying to get periodnames without a :last & :periods definition" 
+      end
+
+      case @periods
+      when :hours
+        (0...@num).map{|i| ((@now.hour - i)%24).to_s}.reverse
+      when :days
+        (1..@num).map{|i| (@now.wday - i)%7}.map{|w| DAYNAMES[w]}.reverse
+      when :weeks
+        initial = @now - (@now.wday-1)*24*60*60
+        (0...@num).map do |i| 
+          time = Time.at(initial - i*24*60*60*7)
+          time.day.to_s+" "+ MONTHNAMES[time.month-1]
+        end.reverse
+      when :months
+        (1..@num).map{|i| (@now.month - i)%12}.map{|m| MONTHNAMES[m]}.reverse
+      when :years
+        (0...@num).map{|i| (@now.year - i).to_s}.reverse
+      else
+        raise RuntimeError, "No such period type #{@periods}" 
+      end
+    end
+
+    private
+    def calc_alignment
+      if [:years, :year].include? periods
+        # Calculate by date manipulation
+        from = Time.utc(@now.year - num + 1, 1, 1, 0, 0, 0)
+        to = Time.utc(@now.year, 12, 31, 23, 59, 59)
+      elsif [:months, :month].include? periods
+        # advance to the 1st of the next month
+        newm = @now.month%12 + 1
+        newy = @now.year + (@now.month == 12 ? 1 : 0)
+        to = Time.utc(newy, newm, 1, 0, 0, 0)
+        # Go back num months for from
+        from = dec_months(num, to)
+        # subtract 1 second from two to get the end of current month
+        to -= 1
+      else
+        # Calculate by elasped time
+        args = [@now.year, @now.month, @now.day, @now.hour, @now.min, @now.sec]
+        args = args[0..-(ALIGN[periods].size+1)]
+        args += ALIGN[periods]
+        to = Time.utc(*args)
+        to += (7-@now.wday)*60*60*24 if [:weeks,:week].include?(periods)
+        from = to - NUMHOURS[periods]*60*60*num+1
+      end
+      @from = from
+      @to = to
     end
-    
-    def normalize_data(data, min, max)
-      data.map do |i|
-        if i.nil?
-          -1.0
-        elsif i < min
-          0.0
-        elsif i > max
-          100.0
-        else
-          v = (((i-min)/(max-min).to_f)*1000).round/10.0
-        end
+
+    # Subtract num months from a given Time
+    def dec_months(num, time)
+      # Go back any 12 month intervals (aka years)
+      newy = time.year - num/12
+      num = num%12
+      # Go back the remainder months
+      newm = time.month - num
+      if newm < 1
+        newm = 12 - (-newm)
+        newy -= 1
       end
+      from = Time.utc(newy, newm, time.day, time.hour, time.min, time.sec)
     end
   end
 end

data/lib/charts.rb

@@ -0,0 +1,23 @@
+module SAAL
+  class Charts
+    include Enumerable
+
+    def initialize(conffile=SAAL::CHARTSCONF, opts={})
+      @defs = YAML::load(File.new(conffile))
+      @sensors = opts[:sensors] || Sensors.new
+      @charts = {}
+      @defs.each do |name, defs|
+        @charts[name.to_sym] = Chart.new(name, defs, @sensors, opts)
+      end  
+    end
+
+    # Fetch a specific chart by name
+    def find(name)
+      @charts[name.to_sym]
+    end
+
+    def each
+      @charts.each{|name, chart| yield chart}
+    end
+  end
+end

data/lib/daemon.rb

@@ -1,13 +1,18 @@
 module SAAL
   class ForkedRunner
     def self.run_as_fork(opts={})
-      fork do
-        if not opts[:keep_stdin]
-          $stderr.reopen "/dev/null", "a"
-          $stdin.reopen "/dev/null", "a"
-          $stdout.reopen "/dev/null", "a"
-        end
+      if opts[:foreground]
+        $stderr.puts "Running saal_daemon #{SAAL::VERSION} in foreground..."
         yield ForkedRunner.new
+      else
+        fork do
+          if not opts[:keep_stdin]
+            $stderr.reopen "/dev/null", "a"
+            $stdin.reopen "/dev/null", "a"
+            $stdout.reopen "/dev/null", "a"
+          end
+          yield ForkedRunner.new
+        end
       end
     end
     

data/lib/dbstore.rb

@@ -67,7 +67,7 @@ module SAAL
       Mysql.quote(text)
     end
 
-    def db_query(query)
+    def db_query(query, opts={})
       db = nil
       begin
         # connect to the MySQL server
@@ -77,7 +77,7 @@ module SAAL
         res = db.query(query)
         yield res if block_given?
       rescue Mysql::Error => e
-        $stderr.puts "MySQL Error \#{e.errno}: \#{e.error}"
+        $stderr.puts "MySQL Error #{e.errno}: #{e.error}" if !(e.errno == opts[:ignoreerr])
       ensure
         db.close if db
       end

data/lib/dinrelay.rb

@@ -10,6 +10,10 @@ module SAAL
         @og = outletgroup
       end
 
+      def sensor_type
+        :onoff
+      end
+
       def read(uncached = false)
         {'ON' => 1.0, 'OFF' => 0.0}[@og.state(@num)]
       end
@@ -33,25 +37,30 @@ module SAAL
 
       def state(num)
         response = do_get('/index.htm')
-        return parse_index_html(response.body)[num]
+        return response ? parse_index_html(response.body)[num] : nil
       end
 
       def set_state(num, state)
         response = do_get("/outlet?#{num}=#{state}")
-        response.code == "200"
+        response != nil
       end
 
       private
       def do_get(path)
-        Net::HTTP.start(@host,@port) do |http|
-          req = Net::HTTP::Get.new(path)
-          req.basic_auth @user, @pass
-          response = http.request(req)
-          if response.code != "200"
-            $stderr.puts "ERROR: Code #{response.code}"
-            $stderr.puts response.body
+        begin
+          Net::HTTP.start(@host,@port) do |http|
+            req = Net::HTTP::Get.new(path)
+            req.basic_auth @user, @pass
+            response = http.request(req)
+            if response.code != "200"
+              #$stderr.puts "ERROR: Code #{response.code}"
+              #$stderr.puts response.body
+              return nil
+            end
+            return response
           end
-          return response
+        rescue Exception
+          return nil
         end
       end
 

data/lib/outliercache.rb

@@ -13,7 +13,7 @@ module SAAL
     # Sets how close the central values have to be for the cache to be "live"
     MAX_CACHE_DEVIATION = 0.05
     # Sets how off the read value can be from the cache median to be accepted
-    MAX_VALUE_DEVIATION = 0.25
+    MAX_VALUE_DEVIATION = 0.15
 
     def initialize
       @compcache = []

data/lib/owsensor.rb

@@ -1,12 +1,15 @@
 module SAAL
   class OWSensor < SensorUnderlying
-    attr_reader :serial
+    attr_reader :serial, :sensor_type
     def initialize(defs, opts={})
       @serial = defs['serial']
       @connect_opts = {}
       @connect_opts[:server] = defs['server'] if defs['server']
       @connect_opts[:port] = defs['port'] if defs['port']
       @owconn = opts[:owconn]
+
+      basename = File.basename(@serial)
+      @sensor_type = basename.to_sym if ['pressure','temperature','humidity'].include?(basename)
     end
 
     def read(uncached = false)

data/lib/saal.rb

@@ -8,8 +8,9 @@ module SAAL
     CONFDIR = "/etc/saal/"
     SENSORSCONF = CONFDIR+"sensors.yml"
     DBCONF = CONFDIR+"database.yml"
+    CHARTSCONF = CONFDIR+"charts.yml"
 
-    VERSION = '0.2.2'
+    VERSION = '0.2.11'
 end
 
 require File.dirname(__FILE__)+'/dbstore.rb'
@@ -17,6 +18,8 @@ require File.dirname(__FILE__)+'/sensors.rb'
 require File.dirname(__FILE__)+'/sensor.rb'
 require File.dirname(__FILE__)+'/owsensor.rb'
 require File.dirname(__FILE__)+'/daemon.rb'
+require File.dirname(__FILE__)+'/charts.rb'
+require File.dirname(__FILE__)+'/chart.rb'
 require File.dirname(__FILE__)+'/chart_data.rb'
 require File.dirname(__FILE__)+'/outliercache.rb'
 require File.dirname(__FILE__)+'/dinrelay.rb'

data/lib/sensor.rb

@@ -3,6 +3,7 @@ module SAAL
   end
 
   class SensorUnderlying
+    def sensor_type; nil; end
     def writeable?; false; end
     def self.writeable! 
       define_method(:writeable?){true}
@@ -26,14 +27,24 @@ module SAAL
       @min_value = defs['min_value']
       @min_correctable = defs['min_correctable']
 
+      @read_offset = if defs['altitude'] && @underlying.sensor_type == :pressure
+        defs['altitude'].to_f/9.2
+      else
+        0.0
+      end
+
       # Outliercache
       @outliercache = opts[:no_outliercache] ? nil : OutlierCache.new
-    end  
+    end
 
     def writeable?
       @underlying.writeable?
     end
 
+    def sensor_type
+      @underlying.sensor_type
+    end
+
     def read
       outlier_proof_read(false)
     end
@@ -52,22 +63,22 @@ module SAAL
 
     def average(from, to)
       return @mock_opts[:average] if @mock_opts[:average]
-      @dbstore.average(@name, from, to)
+      apply_offset @dbstore.average(@name, from, to)
     end
 
     def minimum(from, to)
       return @mock_opts[:minimum] if @mock_opts[:minimum]
-      @dbstore.minimum(@name, from, to)
+      apply_offset @dbstore.minimum(@name, from, to)
     end
 
     def maximum(from, to)
       return @mock_opts[:maximum] if @mock_opts[:maximum]
-      @dbstore.maximum(@name, from, to)
+      apply_offset @dbstore.maximum(@name, from, to)
     end
 
     def store_value
       value = read_uncached
-      @dbstore.write(@name, Time.now.utc.to_i, value) if value
+      @dbstore.write(@name, Time.now.utc.to_i, value-@read_offset) if value
     end
 
     def mock_set(opts)
@@ -87,14 +98,18 @@ module SAAL
       normalize(value)
     end
 
+    def apply_offset(v)
+      v ? v+@read_offset : v
+    end
+
     def normalize(value)
-      if @max_value and value > @max_value
+      apply_offset(if @max_value and value > @max_value
         (@max_correctable and value <= @max_correctable) ? @max_value : nil
       elsif @min_value and value < @min_value
         (@min_correctable and value >= @min_correctable) ? @min_value : nil
       else
         value
-      end
+      end)
     end
   end
 end

data/lib/sensors.rb

@@ -11,8 +11,7 @@ module SAAL
       @sensors =  {}
       @defs.each do |name, defs|
         self.class.sensors_from_defs(@dbstore, name, defs).each{|s| @sensors[s.name] = s}
-      end 
-      
+      end   
     end
         
     # Implements the get methods to fetch a specific sensor
@@ -36,7 +35,9 @@ module SAAL
       elsif defs['dinrelay']
         og = DINRelay::OutletGroup.new(defs['dinrelay'])
         outlet_names = defs['dinrelay']['outlets'] || []
+        outlet_descriptions = defs['dinrelay']['descriptions'] || []
         return outlet_names.map do |num, oname|
+          defs.merge!('name' => outlet_descriptions[num])
           Sensor.new(dbstore, oname, DINRelay::Outlet.new(num.to_i, og), defs, opts)
         end
       else

data/saal.gemspec

@@ -6,8 +6,8 @@ Gem::Specification.new do |s|
   s.platform = Gem::Platform::RUBY
 
   s.name              = 'saal'
-  s.version           = '0.2.2'
-  s.date              = '2010-12-29'
+  s.version           = '0.2.11'
+  s.date              = '2011-05-26'
 
   s.summary     = "Thin abstraction layer for interfacing and recording sensors (currently onewire) and actuators (currently dinrelay)"
   s.description = <<EOF
@@ -46,7 +46,9 @@ EOF
     bin/saal_dump_database
     bin/saal_import_mysql
     bin/saal_readall
+    lib/chart.rb
     lib/chart_data.rb
+    lib/charts.rb
     lib/daemon.rb
     lib/dbstore.rb
     lib/dinrelay.rb
@@ -57,6 +59,8 @@ EOF
     lib/sensors.rb
     saal.gemspec
     test/chart_data_test.rb
+    test/chart_test.rb
+    test/charts_test.rb
     test/daemon_test.rb
     test/dbstore_test.rb
     test/dinrelay.html.erb
@@ -65,6 +69,7 @@ EOF
     test/outliercache_test.rb
     test/sensor_test.rb
     test/sensors_test.rb
+    test/test_charts.yml
     test/test_db.yml
     test/test_dinrelay_sensors.yml
     test/test_helper.rb

data/test/chart_data_test.rb

@@ -18,22 +18,115 @@ class MockSensor
   end
 end
 
-class TestChartData < Test::Unit::TestCase
-  def test_get_data
+class TestChartData < Test::Unit::TestCase  
+  def test_basic_range
     sensor = MockSensor.new
-    c = SAAL::ChartData.new(sensor)
-    assert_equal MOCK_AVERAGES, c.get_data(0, 1000, 5)
-    assert_equal([[0,199],[200,399],[400,599],[600,799],[800,1000]],
+    range = SAAL::ChartDataRange.new(:from => 1, :to => 1000)
+    assert_equal MOCK_AVERAGES, range.get_data(:average, sensor, 5)
+    assert_equal([[1,200],[201,400],[401,600],[601,800],[801,1000]],
                  sensor.asked_averages)
   end
-  
-  def test_normalize_data
+
+  def test_interval_range
+    sensor = MockSensor.new
+    now = Time.utc(2010, 12, 30, 15, 38, 19)
+    ranges = [[1293638400,1293655679],[1293655680,1293672959],
+              [1293672960,1293690239],[1293690240,1293707519],
+              [1293707520,1293724799]]
+    range = SAAL::ChartDataRange.new(:last => 24, :periods => :hours, :now => now)
+    assert_equal MOCK_AVERAGES, range.get_data(:average, sensor, 5)
+    assert_equal ranges, sensor.asked_averages
+  end
+
+  def test_correct_time_use
     sensor = MockSensor.new
-    c = SAAL::ChartData.new(sensor)
-    d = c.get_data(0, 1000, 5)
-    assert_equal NORMALIZED_MOCK_AVERAGES, 
-                 c.normalize_data(d, MOCK_MIN, MOCK_MAX)
-    assert_equal([[0,199],[200,399],[400,599],[600,799],[800,1000]],
-                 sensor.asked_averages)    
+    range = SAAL::ChartDataRange.new(:last => 24, :periods => :hours)
+    now = Time.now.utc
+    to = Time.utc(now.year,now.month,now.day,now.hour,59,59).to_i
+    from = to - 24*60*60 + 1
+    assert_equal MOCK_AVERAGES[0..0], range.get_data(:average, sensor, 1)
+    assert_equal [[from,to]], sensor.asked_averages
+  end
+  
+  # Test all the alignment functions underlying :last, :periods
+  def self.assert_alignment_interval(num,periods,from,to, periodnames=nil, 
+                                     now = nil, extra=nil)
+    define_method("test_alignment_#{num}#{periods}#{extra.to_s}") do
+      now = now || Time.utc(2010, 12, 30, 15, 38, 19)
+      o = SAAL::ChartDataRange.new(:last => num, :periods => periods, :now => now)
+      assert_equal [from.to_i, to.to_i], [o.from, o.to],
+                   "Expecting #{from.utc} - #{to.utc}\n"+
+                   "Got #{Time.at(o.from).utc} - #{Time.at(o.to).utc}"
+      assert_equal periodnames, o.periodnames if periodnames
+    end
+  end
+  assert_alignment_interval(24, :hours, Time.utc(2010, 12, 29, 16, 0, 0),
+                                        Time.utc(2010, 12, 30, 15, 59, 59),
+                            (16..23).map{|s| s.to_s}+(0..15).map{|s| s.to_s})
+
+  assert_alignment_interval(22, :hours, Time.utc(2010, 12, 29, 18, 0, 0),
+                                        Time.utc(2010, 12, 30, 15, 59, 59),
+                            (18..23).map{|s| s.to_s}+(0..15).map{|s| s.to_s})
+
+  assert_alignment_interval(1, :days, Time.utc(2010, 12, 30, 0, 0, 0),
+                                      Time.utc(2010, 12, 30, 23, 59, 59),
+                            ["Thu"])
+
+  assert_alignment_interval(12, :hours, Time.utc(2010, 12, 30, 4, 0, 0),
+                                        Time.utc(2010, 12, 30, 15, 59, 59),
+                            (4..15).map{|s| s.to_s})
+
+  assert_alignment_interval(1, :weeks,Time.utc(2010, 12, 27, 0, 0, 0),
+                                      Time.utc(2011, 1, 2, 23, 59, 59),
+                            ["27 Dec"])
+
+  assert_alignment_interval(2, :weeks,Time.utc(2010, 12, 20, 0, 0, 0),
+                                      Time.utc(2011, 1, 2, 23, 59, 59),
+                            ["20 Dec","27 Dec"])
+
+  assert_alignment_interval(1, :years, Time.utc(2010, 1, 1, 0, 0, 0),
+                                        Time.utc(2010, 12, 31, 23, 59, 59),
+                            ["2010"])
+
+  assert_alignment_interval(2, :years, Time.utc(2009, 1, 1, 0, 0, 0),
+                                        Time.utc(2010, 12, 31, 23, 59, 59),
+                            ["2009","2010"])
+
+  assert_alignment_interval(1, :months, Time.utc(2010, 12, 1, 0, 0, 0),
+                                        Time.utc(2010, 12, 31, 23, 59, 59),
+                            ["Dec"])
+  assert_alignment_interval(1, :months, Time.utc(2010, 4, 1, 0, 0, 0),
+                                        Time.utc(2010, 4, 30, 23, 59, 59),
+                            ["Apr"],    Time.utc(2010, 4, 30, 12, 50, 30), 
+                                       "_30day_month")
+
+  assert_alignment_interval(12, :months, Time.utc(2010, 1, 1, 0, 0, 0),
+                                        Time.utc(2010, 12, 31, 23, 59, 59),
+                            ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug",
+                             "Sep","Oct","Nov","Dec"])
+
+  assert_alignment_interval(13, :months, Time.utc(2009, 12, 1, 0, 0, 0),
+                                        Time.utc(2010, 12, 31, 23, 59, 59))
+  assert_alignment_interval(24, :months, Time.utc(2009, 1, 1, 0, 0, 0),
+                                        Time.utc(2010, 12, 31, 23, 59, 59))
+  assert_alignment_interval(12, :months, Time.utc(2010, 2, 1, 0, 0, 0),
+                                       Time.utc(2011, 1, 31, 23, 59, 59),
+                            ["Feb","Mar","Apr","May","Jun","Jul","Aug",
+                             "Sep","Oct","Nov","Dec","Jan"],
+                                       Time.utc(2011, 1, 1, 14, 15, 10),
+                            "_midyear")
+
+  def self.assert_dec_months(num, from, to)
+    define_method("test_dec_#{num}months_from#{from.join('-')}_to#{to.join('-')}") do
+      o = SAAL::ChartDataRange.new
+      assert_equal Time.utc(to[0], to[1], 1, 0, 0, 0),
+                   o.send(:dec_months, num, Time.utc(from[0],from[1],1,0,0,0))
+    end
   end
+
+  assert_dec_months 2, [2010,12],[2010,10]
+  assert_dec_months 12, [2011,1],[2010,1]
+  assert_dec_months 24, [2011,1],[2009,1]
+  assert_dec_months 2, [2011,1],[2010,11]
+  assert_dec_months 14, [2011,1],[2009,11]
 end

data/test/chart_test.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__)+'/test_helper.rb'
+
+class TestChart < Test::Unit::TestCase
+  def setup
+    @defs = YAML::load File.new(TEST_CHARTS_FILE)
+    sensors = SAAL::Sensors.new(TEST_SENSORS_FILE, TEST_DBCONF)
+    @charts = SAAL::Charts.new(TEST_CHARTS_FILE, 
+                               :sensors => sensors, 
+                               :now => Time.utc(2010, 12, 30, 15, 38, 19))
+  end
+
+  def test_alignlabels
+    assert_equal :center, @charts.find('week').alignlabels
+    assert_equal :left, @charts.find('4week').alignlabels
+  end
+
+  def test_average
+    name = 'week'
+    defs = @defs[name]
+    chart = @charts.find(name)    
+    assert_equal ['Fri','Sat','Sun','Mon','Tue','Wed','Thu'], chart.periodnames
+    chart.sensors.each {|s| s.mock_set(:average => 1)}
+    assert_equal({:fake_temp => [1], :non_existant => [1]}, chart.average(1))
+  end
+
+  def test_from_to
+    chart = @charts.find('day')
+    assert_equal Time.utc(2010, 12, 29, 16, 0, 0).to_i, chart.from
+    assert_equal Time.utc(2010, 12, 30, 15, 59, 59).to_i, chart.to
+  end
+
+  def test_min_max_avg_1arity
+    name = 'week'
+    defs = @defs[name]
+    chart = @charts.find(name)    
+    assert_equal ['Fri','Sat','Sun','Mon','Tue','Wed','Thu'], chart.periodnames
+    v = {:minimum => 1.0, :maximum => 2.0, :average => 1.5}
+    [:minimum,:maximum,:average].each do |method|
+      chart.sensors.each {|s| s.mock_set(method => v[method])}
+      assert_equal({:fake_temp => [v[method]], :non_existant => [v[method]]}, chart.send(method,1))
+    end
+  end
+  
+  def test_min_max_0arity
+    name = 'week'
+    defs = @defs[name]
+    chart = @charts.find(name)    
+    assert_equal ['Fri','Sat','Sun','Mon','Tue','Wed','Thu'], chart.periodnames
+    v = {:minimum => 1.0, :maximum => 2.0, :average => 1.5}
+    [:minimum,:maximum,:average].each do |method|
+      chart.sensors.each {|s| s.mock_set(method => v[method])}
+      assert_equal({:fake_temp => v[method], :non_existant => v[method]}, chart.send(method))
+    end
+  end
+end

data/test/charts_test.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__)+'/test_helper.rb'
+
+class TestCharts < Test::Unit::TestCase
+  def setup
+    @defs = YAML::load File.new(TEST_CHARTS_FILE)
+    sensors = SAAL::Sensors.new(TEST_SENSORS_FILE, TEST_DBCONF)
+    @charts = SAAL::Charts.new(TEST_CHARTS_FILE, :sensors => sensors)
+  end
+
+  def test_load
+    @defs.each do |name, defs|
+      chart = @charts.find(name)
+      assert_instance_of SAAL::Chart, chart
+      assert_equal name, chart.name
+    end
+  end
+
+  def test_each
+    i = 0
+    @charts.each do |chart|
+      defs = @defs[chart.name]
+      assert_equal defs['last'], chart.num
+      assert_equal defs['periods'], chart.periods
+      assert_equal defs['description'], chart.description
+      assert_equal defs['alt'], chart.alt
+      assert_equal defs['sensors'], chart.sensors.map{|s| s.name.to_s}
+      i += 1
+    end
+    assert_equal @defs.size, i, "Charts.each did not iterate correctly"
+  end
+end

data/test/dinrelay_test.rb

@@ -14,6 +14,7 @@ class TestDINRelay < Test::Unit::TestCase
       @html = opts[:html]
       @user = opts[:user]
       @pass = opts[:pass]
+      @status = opts[:status] || 200
       @feedback = opts[:feedback] || {}
     end
     def do_GET(req, res)
@@ -22,7 +23,8 @@ class TestDINRelay < Test::Unit::TestCase
         user == @user && pass == @pass
       }
       res.body = @html
-      res['Content-Type'] = "text/xml"
+      res.status = @status
+      res['Content-Type'] = "text/html"
     end
   end
 
@@ -84,6 +86,13 @@ class TestDINRelay < Test::Unit::TestCase
   def test_enumerate_sensors
     sensors = SAAL::Sensors.new(TEST_SENSORS_DINRELAY_FILE, TEST_DBCONF)
     assert_equal((1..8).map{|i| "name#{i}"}, sensors.map{|s| s.name}.sort)
+    assert_equal((1..8).map{|i| "description#{i}"}, sensors.map{|s| s.description}.sort)
+  end
+
+  def test_sensor_type
+    SAAL::Sensors.new(TEST_SENSORS_DINRELAY_FILE, TEST_DBCONF).each do |s|
+      assert_equal :onoff, s.sensor_type
+    end
   end
 
   def test_read_sensors
@@ -109,4 +118,20 @@ class TestDINRelay < Test::Unit::TestCase
       end
     end
   end
+
+  def test_failed_connection
+    @vals.each do |num, state|
+      assert_equal nil, @og.state(num)
+      assert !@og.set_state(num,"ON"), "State change working without a server?!"
+    end
+  end
+
+  def test_failed_request
+    with_webrick(:html=>create_index_html(@vals),:status=>404) do |feedback|
+      @vals.each do |num, state|
+        assert_equal nil, @og.state(num)
+        assert !@og.set_state(num,"ON"), "State change working without a server?!"
+      end
+    end
+  end
 end

data/test/sensor_test.rb

@@ -11,10 +11,19 @@ class MockConnection
 end
 
 class MockDBStore
-  attr_accessor :value
+  attr_accessor :value, :stored_value
   def average(sensor, from, to)
     @value
   end
+  def minimum(sensor, from, to)
+    @value
+  end
+  def maximum(sensor, from, to)
+    @value
+  end
+  def write(sensor,date,value)
+    @stored_value = value
+  end
 end
 
 class TestSensor < Test::Unit::TestCase
@@ -92,6 +101,33 @@ class TestSensor < Test::Unit::TestCase
     assert_equal [0]*20+[1000], (1..21).map{@fake3.read_uncached}
   end
 
+  def test_eliminate_outliers
+    correctread = 994.422
+    fakeread = 817.309
+    @conn.values = [correctread]*20 + [fakeread,correctread]
+    assert_equal [correctread]*21, (1..21).map{@fake3.read}
+    @conn.values = [correctread]*20 + [fakeread,correctread]
+    assert_equal [correctread]*21, (1..21).map{@fake3.read_uncached}
+  end
+
+  def test_sealevel_correction
+    sensor = fake_sensor('pressure')
+    @conn.value = @dbstore.value = 1000
+    corrected = 1000+@defs['pressure']['altitude'].to_f/9.2
+    assert_equal corrected, sensor.read
+    sensor.store_value
+    assert_equal 1000, @dbstore.stored_value
+    assert_equal corrected, sensor.minimum(0,100)
+    assert_equal corrected, sensor.maximum(0,100)
+    assert_equal corrected, sensor.average(0,100)
+  end
+
+  def test_sensor_type
+    [:pressure, :humidity, :temperature].each do |type|
+      assert_equal type, fake_sensor(type.to_s).sensor_type
+    end
+  end
+
   def test_mocked
     @mockable = fake_sensor('fake3')
     @conn.value = 1.0

data/test/test_charts.yml

@@ -0,0 +1,27 @@
+day:
+  sensors: [fake_temp, non_existant]
+  last: 24
+  periods: hours
+  alt: Some ALT text
+  description: some description of the chart
+
+week:
+  sensors: [fake_temp, non_existant]
+  last: 7
+  periods: days
+
+4week:
+  sensors: [fake_temp, non_existant]
+  last: 4
+  periods: weeks
+  alignlabels: left
+
+year:
+  sensors: [fake_temp, non_existant]
+  last: 12
+  periods: months
+
+4year:
+  sensors: [fake_temp, non_existant]
+  last: 4
+  periods: years

data/test/test_dinrelay_sensors.yml

@@ -13,4 +13,12 @@ group1:
       6: name6
       7: name7
       8: name8
-
+    descriptions:
+      1: description1
+      2: description2
+      3: description3
+      4: description4
+      5: description5
+      6: description6
+      7: description7
+      8: description8

data/test/test_helper.rb

@@ -8,6 +8,7 @@ class Test::Unit::TestCase
   TEST_SENSORS_DINRELAY_FILE = File.dirname(__FILE__)+'/test_dinrelay_sensors.yml'
   TEST_SENSOR_CLEANUPS_FILE = File.dirname(__FILE__)+'/test_sensor_cleanups.yml'
   TEST_NONEXIST_SENSOR_FILE = File.dirname(__FILE__)+'/nonexistant_sensor.yml'
+  TEST_CHARTS_FILE = File.dirname(__FILE__)+'/test_charts.yml'
   TEST_DBCONF = File.dirname(__FILE__)+'/test_db.yml'
   TEST_DBOPTS = YAML::load(File.new(TEST_DBCONF))
 

data/test/test_sensor_cleanups.yml

@@ -19,3 +19,19 @@ fake3:
   onewire: 
     serial: /10.4AEC29CDBAAB/temperature
 
+pressure:
+  name: "A fake pressure sensor"
+  altitude: 200
+  onewire: 
+    serial: /10.4AEC29CDBAAB/pressure
+temperature:
+  name: "A fake pressure sensor"
+  onewire: 
+    serial: /10.4AEC29CDBAAB/temperature
+humidity:
+  name: "A fake pressure sensor"
+  onewire: 
+    serial: /10.4AEC29CDBAAB/humidity
+
+
+

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: saal
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 1
   prerelease: false
   segments: 
   - 0
   - 2
-  - 2
-  version: 0.2.2
+  - 11
+  version: 0.2.11
 platform: ruby
 authors: 
 - "Pedro C\xC3\xB4rte-Real"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-29 00:00:00 +00:00
+date: 2011-05-26 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -94,7 +94,9 @@ files:
 - bin/saal_dump_database
 - bin/saal_import_mysql
 - bin/saal_readall
+- lib/chart.rb
 - lib/chart_data.rb
+- lib/charts.rb
 - lib/daemon.rb
 - lib/dbstore.rb
 - lib/dinrelay.rb
@@ -105,6 +107,8 @@ files:
 - lib/sensors.rb
 - saal.gemspec
 - test/chart_data_test.rb
+- test/chart_test.rb
+- test/charts_test.rb
 - test/daemon_test.rb
 - test/dbstore_test.rb
 - test/dinrelay.html.erb
@@ -113,6 +117,7 @@ files:
 - test/outliercache_test.rb
 - test/sensor_test.rb
 - test/sensors_test.rb
+- test/test_charts.yml
 - test/test_db.yml
 - test/test_dinrelay_sensors.yml
 - test/test_helper.rb
@@ -157,6 +162,8 @@ specification_version: 2
 summary: Thin abstraction layer for interfacing and recording sensors (currently onewire) and actuators (currently dinrelay)
 test_files: 
 - test/chart_data_test.rb
+- test/chart_test.rb
+- test/charts_test.rb
 - test/daemon_test.rb
 - test/dbstore_test.rb
 - test/dinrelay_test.rb