aca-device-modules 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9a3208fa3bfe5c4883031c977b64704307dc5471
+  data.tar.gz: 2293041e12e1d83d311703f228669c9956fb904a
+SHA512:
+  metadata.gz: 64721a3b8ffd32b26b84b6b5ced65cb9bc803587e9c4a6ad2620414cc0f4c45dec1a2f38537f06686fac618e8760fb93c73c3d0105cc69d9913512685d817f3c
+  data.tar.gz: 5ac2fb618e3ad1451c38aa18ad53265128d89eab9be0057dc45a1baeb6554ed0f928b2132360c54a3e3a2da5822b68c3f0ef12d21eaab2603359c82cdcc82bfa

data/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/README.md

@@ -0,0 +1,3 @@
+# Open Source Modules by ACA
+
+Please feel free to contribute.

data/aca-device-modules.gemspec

@@ -0,0 +1,21 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "aca-device-modules/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = "aca-device-modules"
+  s.version     = AcaDeviceModules::VERSION
+  s.authors     = ["Stephen von Takach"]
+  s.email       = ["steve@cotag.me"]
+  s.homepage    = "http://cotag.me/"
+  s.summary     = "Open Source Control Modules by ACA"
+  s.description = "Building automation and IoT control modules"
+  s.license     = "LGPL3"
+
+  s.files = Dir["{modules,lib}/**/*.rb", "aca-device-modules.gemspec", "LICENSE", "README.md"]
+
+  s.add_dependency "rails"
+  s.add_dependency "orchestrator"
+end

data/lib/aca-device-modules.rb

@@ -0,0 +1,2 @@
+
+require 'aca-device-modules/engine'

data/lib/aca-device-modules/engine.rb

@@ -0,0 +1,8 @@
+module AcaDeviceModules
+    class Engine < ::Rails::Engine
+
+        config.after_initialize do |app|
+            app.config.orchestrator.module_paths << File.expand_path('../../../modules', __FILE__)
+        end
+    end
+end

data/lib/aca-device-modules/version.rb

@@ -0,0 +1,3 @@
+module AcaDeviceModules
+    VERSION = "1.0.0"
+end

data/modules/aca/pc_control.rb

@@ -0,0 +1,142 @@
+module Aca; end
+
+#
+# Settings required:
+#	* domain (domain that we will be authenticating against)
+#	* username (username for authentication)
+#	* password (password for authentication)
+#
+# (built in)
+# connected
+#
+class Aca::PcControl
+	include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+
+	#
+	# 	initialize will not have access to settings
+	#
+	def on_load
+		
+		#
+		# Setup constants
+		#
+		self[:authenticated] = 0
+
+		config({
+			tokenize: true,
+			delimiter: "\x03",
+			indicator: "\x02"
+		})
+	end
+	
+	def connected
+		@polling_timer = schedule.every('60s') do
+            logger.debug "-- Polling Computer"
+            do_send({:control => "app", :command => 'do_nothing'}, {wait: false})
+        end
+	end
+	
+	def disconnected
+		self[:authenticated] = 0
+		@polling_timer.cancel unless @polling_timer.nil?
+        @polling_timer = nil
+	end
+	
+	def launch_application(app, *args)
+		do_send({:control => "app", :command => app, :args => args})
+	end
+
+	def wake(broadcast = nil)
+		mac = setting(:mac_address)
+        if mac
+            # config is the database model representing this device
+            wake_device(mac, broadcast || '<broadcast>')
+        end
+        logger.debug "Waking computer #{mac} #{broadcast}"
+        nil
+	end
+
+	def shutdown
+		launch_application 'shutdown.exe', '/s', '/t', '0'
+	end
+
+	def logoff
+		launch_application 'shutdown.exe', '/l', '/t', '0'
+	end
+
+	def restart
+		launch_application 'shutdown.exe', '/r', '/t', '0'
+	end
+	
+
+
+	#
+	# Camera controls
+	#
+	CAM_OPERATIONS = [:up, :down, :left, :right, :center, :zoomin, :zoomout]
+	
+	#
+	# Automatically creates a callable function for each command
+	#	http://blog.jayfields.com/2007/10/ruby-defining-class-methods.html
+	#	http://blog.jayfields.com/2008/02/ruby-dynamically-define-method.html
+	#
+	CAM_OPERATIONS.each do |command|
+		define_method command do |*args|
+			# Cam control is low priority in case a camera is not plugged in
+			do_send({:control => "cam", :command => command.to_s, :args => []}, {:priority => 0, :retries => 0})
+		end
+	end
+	
+	def zoom(val)
+		do_send({:control => "cam", :command => "zoom", :args => [val.to_s]})
+	end
+	
+	def received(data, resolve, command)
+		
+		#
+		# Convert the message into a native object
+		#
+		data = JSON.parse(data, {:symbolize_names => true})
+		
+		#
+		# Process the response
+		#
+		if data[:command] == "authenticate"
+			command = {:control => "auth", :command => setting(:domain), :args => [setting(:username), setting(:password)]}
+			if self[:authenticated] > 0
+				#
+				# Token retry (probably always fail - at least we can see in the logs)
+				#	We don't want to flood the network with useless commands
+				#
+				schedule.in('60s') do
+					do_send(command)
+				end
+				logger.info "-- Pod Computer, is refusing authentication"
+			else
+				do_send(command)
+			end
+			self[:authenticated] += 1
+			logger.debug "-- Pod Computer, requested authentication"
+		elsif data[:type] != nil
+			self["#{data[:device]}_#{data[:type]}"] = data	# zoom, tilt, pan
+			return nil	# This is out of order data
+		else
+			if !data[:result]
+				logger.warn "-- Pod Computer, request failed for command: #{command ? command[:data] : "(resp #{data})"}"
+				return false
+			end
+		end
+		
+		return true # Command success
+	end
+	
+	
+	private
+	
+
+	def do_send(command, options = {})
+		send("\x02#{JSON.generate(command)}\x03", options)
+	end
+end
+

data/modules/axis/camera/vapix.rb

@@ -0,0 +1,280 @@
+module Axis; end
+module Axis::Camera; end
+
+
+class Axis::Camera::Vapix
+    include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+
+    def on_load
+        on_update
+    end
+
+    def on_update
+        defaults({
+            delay: 130,
+            keepalive: false
+        })
+
+        @username = setting(:username)
+        unless @username.nil?
+            @password = setting(:password)
+        end
+
+        self[:pan_max] = 180.0
+        self[:pan_min] = -180.0
+        self[:pan_center] = 0.0
+        self[:tilt_max] = 180.0
+        self[:tilt_min] = -180.0
+        self[:tilt_center] = 0.0
+
+        self[:joy_left] = -100
+        self[:joy_right] = 100
+        self[:joy_center] = 0
+
+        self[:zoom_max] = 9999
+        self[:zoom_min] = 0
+
+        self[:focus_max] = 9999
+        self[:focus_min] = 0
+
+        self[:iris_max] = 9999
+        self[:iris_min] = 0
+
+        self[:power] = true
+    end
+
+    
+    def connected
+        schedule.every('60s', method(:do_poll))
+        do_poll
+    end
+
+
+    # Here for cross module compatibility
+    def power(state = nil, &blk)
+        blk.call true
+    end
+
+    def pantilt(pan = nil, tilt = nil)
+        pt = {
+            pan: in_range(pan.to_f, self[:pan_max], self[:pan_min]),
+            tilt: in_range(tilt.to_f, self[:tilt_max], self[:tilt_min])
+        }
+        
+        req(:ptz, pt, {name: :pantilt}) do |data, resolve|
+            val = extract(data, resolve)
+            if val == :success
+                self[:pan] = pt[:pan]
+                self[:tilt] = pt[:tilt]
+                :success
+            end
+        end
+    end
+
+    def joystick(pan_speed, tilt_speed)
+        left_max = self[:joy_left]
+        right_max = self[:joy_right]
+        pan_speed = in_range(pan_speed.to_i, right_max, left_max)
+        tilt_speed = in_range(tilt_speed.to_i, right_max, left_max)
+
+        is_centered = false
+        if pan_speed == 0 && tilt_speed == 0
+            is_centered = true
+        end
+
+        options = {}
+        options[:retries] = is_centered ? 1 : 0
+        options[:name] = :joystick
+
+        logger.debug("Sending camera: #{pan_speed}#{tilt_speed}")
+
+        req(:ptz, "continuouspantiltmove=#{pan_speed},#{tilt_speed}", options) do |data, resolve|
+            val = extract(data, resolve)
+            if val == :success
+                self[:joy_pan] = pan_speed
+                self[:joy_tilt] = tilt_speed
+                :success
+            end
+        end
+    end
+
+
+    def zoom(pos)
+        pos = in_range(pos.to_i, self[:zoom_max], self[:zoom_min])
+
+        req(:ptz, "zoom=#{pos}", {name: :zoom}) do |data, resolve|
+            val = extract(data, resolve)
+            if val == :success
+                self[:zoom] = pos
+                :success
+            end
+        end
+    end
+
+
+    def focus(pos)
+        pos = in_range(pos.to_i, self[:focus_max], self[:focus_min])
+
+        req(:ptz, "focus=#{pos}", {name: :focus}) do |data, resolve|
+            val = extract(data, resolve)
+            if val == :success
+                self[:focus] = pos
+                :success
+            end
+        end
+    end
+
+    def auto_focus(state)
+        state = is_affirmative?(state) ? 'on' : 'off'
+        
+        req(:ptz, "autofocus=#{state}", {name: :auto_focus}) do |data, resolve|
+            val = extract(data, resolve)
+            if val == :success
+                self[:auto_focus] = state == 'on'
+                :success
+            end
+        end
+    end
+
+    def iris(level)
+        level = in_range(level.to_i, self[:iris_max], self[:iris_min])
+
+        req(:ptz, "iris=#{level}", {name: :iris}) do |data, resolve|
+            val = extract(data, resolve)
+            if val == :success
+                self[:iris] = level
+                :success
+            end
+        end
+    end
+
+    def auto_iris(state)
+        state = is_affirmative?(state) ? 'on' : 'off'
+        
+        req(:ptz, "autoiris=#{state}", {name: :auto_iris}) do |data, resolve|
+            val = extract(data, resolve)
+            if val == :success
+                self[:auto_iris] = state == 'on'
+                :success
+            end
+        end
+    end
+
+
+    def query_ptz(var)
+        req(:ptz, "query=#{var}", {name: "query_#{var}", priority: 0}) do |data, resolve|
+            val = extract(data, resolve)
+            if val.is_a? Hash
+                val.each_pair do |key, value|
+                    set_status(key, value)
+                end
+            end
+            :success
+        end
+    end
+
+
+    protected
+
+
+    REQUESTS = {
+        ptz: '/axis-cgi/com/ptz.cgi'
+    }
+
+
+    def req(type, params = nil, options = {}, &blk)
+        request = REQUESTS[type] || type
+
+        unless @username.nil?
+            options[:headers] ||= {}
+            options[:headers]['authorization'] = [@username, @password]
+        end
+
+        if params.is_a?(Hash) && !params.empty?
+            request += '?' # new string object
+            params.each do |key, value|
+                request << "#{key}=#{value}&"
+            end
+            request.chop!
+        elsif params
+            request += "?#{params}"
+        end
+
+        get(request, options, &blk)
+    end
+
+    def extract(data, resolv)
+        body = data[:body].split("\r\n")
+        if body.empty?
+            resolv.call :success
+            logger.debug "empty body = success"
+            :success
+        elsif body[0] == 'Error:'
+            cmd = data[:request]
+            logger.warn "Camera error response: #{body[1]} for #{cmd[:path]} #{cmd[:query]}"
+            resolv.call(:failed)
+            :failed
+        else
+            resp = {}
+            body.each do |line|
+                components = line.split('=')
+                resp[components[0].to_sym] = components[1]
+            end
+            logger.debug "returned #{resp}"
+            resp
+        end
+    end
+
+    def do_poll(*args)
+        if not self[:limits_configured]
+            query_ptz :limits
+        end
+        query_ptz :position
+    end
+
+    def set_status(key, value)
+        case key
+
+        # query limits
+        when :MinPan
+            self[:limits_configured] = true
+            self[:pan_min] = value.to_f
+        when :MaxPan
+            self[:pan_max] = value.to_f
+        when :MinTilt
+            self[:tilt_min] = value.to_f
+        when :MaxTilt
+            self[:tilt_max] = value.to_f
+        when :MinZoom
+            self[:zoom_min] = value.to_i
+        when :MaxZoom
+            self[:zoom_max] = value.to_i
+        when :MinIris
+            self[:iris_min] = value.to_i
+        when :MaxIris
+            self[:iris_max] = value.to_i
+        when :MinFocus
+            self[:focus_min] = value.to_i
+        when :MaxFocus
+            self[:focus_max] = value.to_i
+
+        # query position
+        when :pan
+            self[:pan] = value.to_f
+        when :tilt
+            self[:tilt] = value.to_f
+        when :zoom
+            self[:zoom] = value.to_i
+        when :autofocus
+            self[:autofocus] = value == 'on'
+        when :autoiris
+            self[:autoiris] = value == 'on'
+
+        # query speed
+        when :speed
+            self[:speed] = value.to_i
+        end
+    end
+end
+