aca-device-modules 1.0.0

data/modules/panasonic/camera/he50.rb

@@ -0,0 +1,346 @@
+module Panasonic; end
+module Panasonic::Camera; end
+
+
+class Panasonic::Camera::He50
+    include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+
+    def on_load
+        on_update
+    end
+
+    def on_update
+        defaults({
+            delay: 130,         # As per the manual page 8
+            keepalive: false,
+            inactivity_timeout: 1.5,  # seconds before closing the connection if no response
+            connect_timeout: 2        # max seconds for the initial connection to the device
+        })
+
+        self[:pan_max] = 0xD2F5
+        self[:pan_min] = 0x2D08
+        self[:pan_center] = 0x7FFF
+        self[:tilt_max] = 0x8E38
+        self[:tilt_min] = 0x5556
+        self[:tilt_center] = 0x7FFF
+
+        self[:joy_left] = 0x01
+        self[:joy_right] = 0x99
+        self[:joy_center] = 0x50
+
+        self[:zoom_max] = 0xFFF
+        self[:zoom_min] = 0x555
+
+        self[:focus_max] = 0xFFF
+        self[:focus_min] = 0x555
+
+        self[:iris_max] = 0xFFF
+        self[:iris_min] = 0x555
+
+        # {near: {zoom: val, pan: val, tilt: val}}
+        @presets = setting(:presets) || {}
+        self[:presets] = @presets.keys
+    end
+    
+    def connected
+        schedule.every('60s', method(:do_poll))
+        do_poll
+    end
+
+
+    RESP = {
+        power: 'p',
+        installation: 'iNS',
+
+        pantilt: 'aPC',
+        joystick: 'pTS',
+        limit: 'lC',
+
+        zoom: /axz|gz/,
+        manual_zoom: 'zS',
+        link_zoom: 'sWZ',
+
+        focus: /axf|gf/,
+        manual_focus: 'fS',
+        auto_focus: 'd1',
+
+        iris: /axi|gi/,
+        auto_iris: 'd3'
+    }
+    LIMITS = {
+        up: 1,
+        down: 2,
+        left: 3,
+        right: 4
+    }
+    LIMITS.merge!(LIMITS.invert)
+
+
+    # Responds with:
+    # 0 == standby
+    # 1 == power on
+    # 3 == powering on
+    def power(state = nil, &blk)
+        state = (is_affirmative?(state) ? 1 : 0) unless state.nil?
+
+        options = {}
+        options[:emit] = blk if blk
+        options[:delay] = 6000 if state
+
+        logger.debug "Camera requested power #{state}"
+        
+        req('O', state, :power, options) do |data, resolve|
+            val = extract(:power, data, resolve)
+            if val
+                self[:power] = val.to_i > 0
+                :success
+            end
+        end
+    end
+
+    def installation(pos = nil)
+        pos = (pos.to_sym == :desk ? 0 : 1) if pos
+        
+        req('INS', pos, :installation) do |data, resolve|
+            val = extract(:installation, data, resolve)
+            if val
+                self[:installation] = val == '0' ? :desk : :ceiling
+                :success
+            end
+        end
+    end
+
+    def pantilt(pan = nil, tilt = nil)
+        unless pan.nil?
+            pan = in_range(pan.to_i, self[:pan_max], self[:pan_min]).to_s(16).upcase.rjust(4, '0')
+            tilt = in_range(tilt.to_i, self[:tilt_max], self[:tilt_min]).to_s(16).upcase.rjust(4, '0')
+        end
+        
+        req('APC', "#{pan}#{tilt}", :pantilt) do |data, resolve|
+            val = extract(:pantilt, data, resolve)
+            if val
+                comp = []
+                val.scan(/.{4}/) { |com| comp << com.to_i(16) }
+                self[:pan] = comp[0]
+                self[:tilt] = comp[1]
+                :success
+            end
+        end
+    end
+
+    # Recall a preset from the database
+    def preset(name)
+        values = @presets[name.to_sym]
+        if values
+            pantilt(values[:pan], values[:tilt])
+            zoom(values[:zoom])
+            true
+        else
+            false
+        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).to_s(16).upcase.rjust(2, '0')
+        tilt_speed = in_range(tilt_speed.to_i, right_max, left_max).to_s(16).upcase.rjust(2, '0')
+
+        is_centered = false
+        if pan_speed == '50' && tilt_speed == '50'
+            is_centered = true
+        end
+
+        options = {}
+        options[:retries] = is_centered ? 1 : 0
+
+        logger.debug("Sending camera: #{pan_speed}#{tilt_speed}");
+
+        req('PTS', "#{pan_speed}#{tilt_speed}", :joystick, options) do |data, resolve|
+            val = extract(:joystick, data, resolve)
+            if val
+                comp = []
+                val.scan(/.{2}/) { |com| comp << com.to_i(16) }
+                self[:joy_pan] = comp[0]
+                self[:joy_tilt] = comp[1]
+                :success
+            end
+        end
+    end
+
+    def limit(direction, state = nil)
+        dir = LIMITS[direction.to_sym]
+        state = (is_affirmative?(set) ? 1 : 0) unless state.nil?
+
+        req('LC', "#{dir}#{state}", :limit) do |data, resolve|
+            val = extract(:limit, data, resolve)
+            if val
+                self[:"limit_#{LIMITS[val[0].to_i]}"] = val[1] == '1'
+                :success
+            end
+        end
+    end
+
+
+    def zoom(pos = nil)
+        cmd = 'AXZ'
+        if pos
+            pos = in_range(pos.to_i, self[:zoom_max], self[:zoom_min]).to_s(16).upcase.rjust(3, '0')
+        else
+            cmd = 'GZ'
+        end
+
+        req(cmd, pos, :zoom) do |data, resolve|
+            val = extract(:zoom, data, resolve)
+            if val
+                self[:zoom] = val.to_i(16)
+                :success
+            end
+        end
+    end
+
+    def manual_zoom(speed)
+        speed = in_range(speed.to_i, self[:joy_right], self[:joy_left]).to_s(16).upcase.rjust(3, '0')
+
+        req('Z', speed, :manual_zoom) do |data, resolve|
+            val = extract(:manual_zoom, data, resolve)
+            if val
+                self[:manual_zoom] = val.to_i(16)
+                :success
+            end
+        end
+    end
+
+    def link_zoom(state = nil) # Link pantilt speed to zoom
+        state = (is_affirmative?(state) ? 1 : 0) unless state.nil?
+        
+        req('SWZ', state, :link_zoom) do |data, resolve|
+            val = extract(:link_zoom, data, resolve)
+            if val
+                self[:link_zoom] = val == '1'
+                :success
+            end
+        end
+    end
+
+
+    def focus(pos = nil)
+        cmd = 'AXF'
+        if pos
+            pos = in_range(pos.to_i, self[:focus_max], self[:focus_min]).to_s(16).upcase.rjust(3, '0')
+        else
+            cmd = 'GF'
+        end
+
+        req(cmd, pos, :focus) do |data, resolve|
+            val = extract(:focus, data, resolve)
+            if val
+                self[:focus] = val.to_i(16)
+                :success
+            end
+        end
+    end
+
+    def manual_focus(speed)
+        speed = in_range(speed.to_i, self[:joy_right], self[:joy_left]).to_s(16).upcase.rjust(2, '0')
+
+        req('F', speed, :manual_focus) do |data, resolve|
+            val = extract(:manual_focus, data, resolve)
+            if val
+                self[:manual_focus] = val.to_i(16)
+                :success
+            end
+        end
+    end
+
+    def auto_focus(state = nil)
+        state = (is_affirmative?(state) ? 1 : 0) unless state.nil?
+        
+        req('D1', state, :auto_focus) do |data, resolve|
+            val = extract(:auto_focus, data, resolve)
+            if val
+                self[:auto_focus] = val == '1'
+                :success
+            end
+        end
+    end
+
+
+    def iris(level = nil)
+        cmd = 'AXI'
+        if level
+            level = in_range(level.to_i, self[:iris_max], self[:iris_min]).to_s(16).upcase.rjust(3, '0')
+        else
+            cmd = 'GI'
+        end
+
+        req(cmd, level, :iris) do |data, resolve|
+            val = extract(:iris, data, resolve)
+            if val
+                self[:iris] = val[0..2].to_i(16)
+                if val.length == 4
+                    self[:auto_iris] = val == '1'
+                end
+                :success
+            end
+        end
+    end
+
+    def auto_iris(state = nil)
+        state = (is_affirmative?(state) ? 1 : 0) unless state.nil?
+        
+        req('D3', state, :auto_iris) do |data, resolve|
+            val = extract(:auto_iris, data, resolve)
+            if val
+                self[:auto_iris] = val == '1'
+                :success
+            end
+        end
+    end
+
+
+    protected
+
+
+    def req(cmd, data, name, options = {}, &blk)
+        if data.nil? || (data.respond_to?(:empty?) && data.empty?)
+            options[:delay] = 0
+            options[:priority] = 0 # Actual commands have a higher priority
+        else
+            options[:name] = name
+        end
+        request_string = "/cgi-bin/aw_ptz?cmd=%23#{cmd}#{data}&res=1"
+        get(request_string, options, &blk)
+
+        logger.debug "requesting #{name}: #{request_string}"
+    end
+
+    def extract(name, data, resp)
+        logger.debug "received #{data} for command #{name}"
+
+        body = data[:body]
+        if body[0] == 'e'
+            notify_error(body, 'invalid command sent', data)
+            resp.call(:failed)
+            nil
+        else
+            body.sub(RESP[name], '')
+        end
+    end
+
+    def do_poll(*args)
+        power do
+            if self[:power] # only request status if online
+                pantilt
+                zoom
+            end
+        end
+    end
+
+    def notify_error(err, msg, cmd)
+        cmd = cmd[:request]
+        logger.warn "Camera error response: #{err} - #{msg} for #{cmd[:path]} #{cmd[:query]}"
+    end
+end
+

data/modules/panasonic/projector/pj_link.rb

@@ -0,0 +1,266 @@
+module Panasonic; end
+module Panasonic::Projector; end
+
+
+require 'digest/md5'
+
+#
+# Port: 1024
+#
+class Panasonic::Projector::PjLink
+	include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+
+	def on_load
+		# PJLink is slow
+		defaults({
+			timeout: 4000,
+			delay_on_receive: 400
+		})
+
+		config({
+			tokenize: true,
+			delimiter: "\r",
+			wait_ready: 'NTCONTROL'
+		})
+
+		@check_scheduled = false
+		self[:power] = false
+		self[:stable_state] = true  # Stable by default (allows manual on and off)
+		self[:input_stable] = true
+		
+		# Meta data for inquiring interfaces
+		self[:type] = :projector
+	end
+
+	def on_update
+	end
+	
+	def connected
+		@polling_timer = schedule.every('60s', method(:do_poll))
+	end
+
+	def disconnected
+		self[:power] = false
+
+		@polling_timer.cancel unless @polling_timer.nil?
+        @polling_timer = nil
+	end
+	
+	
+	
+	#
+	# Power commands
+	#
+	def power(state, opt = nil)
+		self[:stable_state] = false
+		if is_affirmative?(state)
+			self[:power_target] = On
+			do_send(:POWR, 1, {:retries => 10, :name => :power})
+			logger.debug "-- panasonic Proj, requested to power on"
+			do_send('POWR', '?', :name => :power_state)
+		else
+			self[:power_target] = Off
+			do_send(:POWR, 0, {:retries => 10, :name => :power})
+			logger.debug "-- panasonic Proj, requested to power off"
+			do_send('POWR', '?', :name => :power_state)
+		end
+	end
+
+	def power?(options = {}, &block)
+		options[:emit] = block if block_given?
+		options[:name] = :power_state
+		do_send(:POWR, options)
+	end
+	
+	
+	
+	#
+	# Input selection
+	#
+	INPUTS = {
+		:hdmi => 31,
+		:hdmi2 => 32,
+		:digital => 33,
+		:miracast => 52
+	}
+	INPUTS.merge!(INPUTS.invert)
+	
+	
+	def switch_to(input)
+		input = input.to_sym
+		return unless INPUTS.has_key? input
+		
+		do_send(:INPT, INPUTS[input], {:retries => 10, :name => :inpt_source})
+		do_send('INPT', '?', {:name => :inpt_query})
+		logger.debug "-- panasonic LCD, requested to switch to: #{input}"
+		
+		self[:input] = input	# for a responsive UI
+		self[:input_stable] = false
+	end
+	
+	
+	#
+	# Mute Audio and Video
+	#
+	def mute
+		logger.debug "-- panasonic Proj, requested to mute"
+		do_send(:AVMT, 31, {:name => :video_mute})	# Audio + Video
+	end
+
+	def unmute
+		logger.debug "-- panasonic Proj, requested to unmute"
+		do_send(:AVMT, 30, {:name => :video_mute})
+	end
+	
+	
+	ERRORS = {
+		:ERR1 => '1: Undefined control command'.freeze,
+		:ERR2 => '2: Out of parameter range'.freeze,
+		:ERR3 => '3: Busy state or no-acceptable period'.freeze,
+		:ERR4 => '4: Timeout or no-acceptable period'.freeze,
+		:ERR5 => '5: Wrong data length'.freeze,
+		:ERRA => 'A: Password mismatch'.freeze
+	}
+	
+
+	def received(data, resolve, command)		# Data is default received as a string
+		logger.debug "panasonic Proj sent: #{data}"
+
+		# This is the ready response 
+		if data[0] == ' '
+			@mode = data[1]
+			if @mode == '1'
+				@pass = "#{setting(:username) || 'admin1'}:#{setting(:password) || 'panasonic'}:#{data.strip.split(/\s+/)[-1]}"
+				@pass = Digest::MD5.hexdigest(@hash)
+			end
+
+			:success
+
+		# Error Response
+		elsif data[0] == 'E'
+			error = data.to_sym
+			#self[:last_error] = ERRORS[error] (for error status query)
+
+			# Check for busy or timeout
+			if error == :ERR3 || error == :ERR4
+				logger.warn "Panasonic Proj busy: #{self[:last_error]}"
+				:retry
+			else
+				logger.error "Panasonic Proj error: #{self[:last_error]}"
+				:abort
+			end
+			
+		# Success Response
+		else
+			data = data[2..-1].split('=')
+
+			if data[1] = 'OK'
+				return :success
+			else
+				type = data[0][2..-1].to_sym
+				response = data[1].to_i
+				resolve.call(:success)
+
+				case type
+				when :POWR
+					self[:power] = response >= 1 && response != 2
+					self[:warming] = response == 3
+					self[:cooling] = response == 2
+					if response >= 2 && !@check_scheduled && !self[:stable_state]
+						@check_scheduled = true
+						schedule.in('20s') do
+							@check_scheduled = false
+							logger.debug "-- checking panasonic state"
+							power?({:priority => 0}) do
+								state = self[:power]
+								if state != self[:power_target]
+									if self[:power_target] || !self[:cooling]
+										power(self[:power_target])
+									end
+								elsif self[:power_target] && self[:cooling]
+									power(self[:power_target])
+								else
+									self[:stable_state] = true
+									switch_to(self[:input]) if self[:power_target] == On && !self[:input].nil?
+								end
+							end
+						end
+					end
+				when :INPT
+					if INPUTS[response].present?
+						self[:input] = INPUTS[response] if self[:input].nil?
+						self[:actual_input] = INPUTS[response]
+						if self[:input] == self[:actual_input]
+							self[:input_stable] = true
+						elsif self[:input_stable] == false
+							schedule.in('5s') do
+								logger.debug "-- forcing panasonic input"
+								switch_to(self[:input]) if self[:input_stable] == false
+							end
+						end
+					end
+				when :AVMT
+					self[:mute] = response == 31	# 10 == video mute off, 11 == video mute, 20 == audio mute off, 21 == audio mute, 30 == AV mute off
+				when :LAMP
+					self[:lamp] = data[1][0..-2].to_i
+				end
+			end
+		end
+	end
+
+	
+	
+	protected
+	
+	
+	def do_poll(*args)
+		power?({:priority => 0}) do
+			if self[:power]
+				if self[:stable_state] == false && self[:power_target] == Off
+					power(Off)
+				else
+					self[:stable_state] = true
+					do_send(:INPT, {
+						:name => :inpt_query,
+						:priority => 0
+					})
+					do_send(:AVMT, {
+						:name => :mute_query,
+						:priority => 0
+					})
+					do_send(:LAMP, {
+						:name => :lamp_query,
+						:priority => 0
+					})
+				end
+			elsif self[:stable_state] == false
+				if self[:power_target] == On
+					power(On)
+				else
+					self[:stable_state] = true
+				end
+			end
+		end
+	end
+
+	def do_send(command, param = nil, options = {})
+		if param.is_a? Hash
+			options = param
+			param = nil
+		end
+
+		if param.nil?
+			pj = "#{command} ?"
+		else
+			pj = "#{command} #{param}"
+		end
+
+		if @mode == '0'
+			send("00#{pj}\r", options)
+		else
+			send("#{@pass}00#{pj}\r", options)
+		end
+	end
+end
+