aca-device-modules 1.0.3 → 1.0.4

data/modules/panasonic/projector/tcp.rb

@@ -0,0 +1,250 @@
+module Panasonic; end
+module Panasonic::Projector; end
+
+
+require 'digest/md5'
+
+#
+# Port: 1024
+#
+class Panasonic::Projector::Tcp
+	include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+
+	def on_load
+		# Response time is slow
+		defaults({
+			timeout: 2000,
+			delay_on_receive: 1000
+		})
+
+		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)
+		
+		# Meta data for inquiring interfaces
+		self[:type] = :projector
+		
+		# The projector drops the connection when there is no activity
+		schedule.every('60s') do
+			power?({:priority => 0})
+		end
+	end
+
+	def on_update
+	end
+	
+	def connected
+	end
+
+	def disconnected
+	end
+
+
+	COMMANDS = {
+		power_on: :PON,
+		power_off: :POF,
+		power_query: :QPW,
+		freeze: :OFZ,
+		input: :IIS,
+		mute: :OSH,
+		lamp: :"Q$S"
+	}
+	COMMANDS.merge!(COMMANDS.invert)
+	
+	
+	
+	#
+	# Power commands
+	#
+	def power(state, opt = nil)
+		self[:stable_state] = false
+		if is_affirmative?(state)
+			self[:power_target] = On
+			do_send(:power_on, {:retries => 10, :name => :power, delay_on_receive: 8000})
+			logger.debug "-- panasonic Proj, requested to power on"
+			do_send(:lamp)
+		else
+			self[:power_target] = Off
+			do_send(:power_off, {:retries => 10, :name => :power, delay_on_receive: 8000})
+			logger.debug "-- panasonic Proj, requested to power off"
+			do_send(:lamp)
+		end
+	end
+
+	def power?(options = {}, &block)
+		options[:emit] = block if block_given?
+		do_send(:lamp, options)
+	end
+	
+	
+	
+	#
+	# Input selection
+	#
+	INPUTS = {
+		:hdmi => :HD1,
+		:hdmi2 => :HD2,
+		:vga => :RG1,
+		:vga2 => :RG2,
+		:miracast => :MC1
+	}
+	INPUTS.merge!(INPUTS.invert)
+	
+	
+	def switch_to(input)
+		input = input.to_sym
+		return unless INPUTS.has_key? input
+
+		# Projector doesn't automatically unmute
+		unmute if self[:mute]
+		
+		do_send(:input, INPUTS[input], {:retries => 10, delay_on_receive: 2000})
+		logger.debug "-- panasonic LCD, requested to switch to: #{input}"
+		
+		self[:input] = input	# for a responsive UI
+	end
+	
+	
+	#
+	# Mute Audio and Video
+	#
+	def mute(val = true)
+		actual = val ? 1 : 0
+		logger.debug "-- panasonic Proj, requested to mute"
+		do_send(:mute, actual)	# Audio + Video
+	end
+
+	def unmute
+		logger.debug "-- panasonic Proj, requested to unmute"
+		do_send(:mute, 0)
+	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,
+		:ER401 => '401: Command cannot be executed'.freeze,
+		:ER402 => '402: Invalid parameter is sent'.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(@pass)
+			end
+
+		else
+			data = data[2..-1]
+
+			# Error Response
+			if data[0] == 'E'
+				error = data.to_sym
+				self[:last_error] = ERRORS[error]
+
+				# Check for busy or timeout
+				if error == :ERR3 || error == :ERR4
+					logger.warn "Panasonic Proj busy: #{self[:last_error]}"
+					return :retry
+				else
+					logger.error "Panasonic Proj error: #{self[:last_error]}"
+					return :abort
+				end
+			end
+
+                        resp = data.split(':')
+			cmd = COMMANDS[resp[0].to_sym]
+			val = resp[1]
+				
+			case cmd
+			when :power_on
+				self[:power] = true
+			when :power_off
+				self[:power] = false
+			when :power_query
+				self[:power] = val.to_i == 1
+			when :freeze
+				self[:frozen] = val.to_i == 1
+			when :input
+				self[:input] = INPUTS[val.to_sym]
+			when :mute
+				self[:mute] = val.to_i == 1
+			else
+				if command && command[:name] == :lamp
+					ival = resp[0].to_i
+					self[:power] = ival == 1 || ival == 2
+					self[:warming] = ival == 1
+					self[:cooling] = ival == 3
+	
+					if (self[:warming] || self[:cooling]) && !@check_scheduled && !self[:stable_state]
+						@check_scheduled = true
+						schedule.in('13s') 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	
+				end
+			end
+		end
+
+		:success
+	end
+
+	
+	protected
+
+
+	def do_send(command, param = nil, options = {})
+		if param.is_a? Hash
+			options = param
+			param = nil
+		end
+
+		# Default to the command name if name isn't set
+		options[:name] = command unless options[:name]
+
+		if param.nil?
+			pj = "#{COMMANDS[command]}"
+		else
+			pj = "#{COMMANDS[command]}:#{param}"
+		end
+
+		if @mode == '0'
+			send("00#{pj}\r", options)
+		else
+			send("#{@pass}00#{pj}\r", options)
+		end
+
+		nil
+	end
+end
+

data/modules/screen_technics/connect.rb

@@ -0,0 +1,73 @@
+module ScreenTechnics; end
+
+
+class ScreenTechnics::Connect
+	include ::Orchestrator::Constants
+
+
+	def on_load
+		defaults({
+            delay: 2000,
+            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[:state] = :up
+	end
+	
+	def on_update
+	end
+	
+	def connected
+	end
+	
+	def state(new_state, index = 1)
+		if is_affirmative?(new_state)
+			down(index)
+		else
+			up(index)
+		end
+	end
+
+	def down(index = 1)
+		stop(index)
+		do_send({
+			state: :down,
+			body: "Down#{index}=Down",
+			name: :"position#{index}",
+			index: index
+		})
+	end
+
+	def up(index = 1)
+		stop(index)
+		do_send({
+			state: :up,
+			body: "Up#{index}=Up",
+			name: :"position#{index}",
+			index: index
+		})
+	end
+
+	def stop(index = 1)
+		do_send({
+			body: "Stop#{index}=Stop",
+			name: :"stop#{index}",
+			priority: 99
+		})
+	end
+
+
+	protected
+
+
+	def do_send(options)
+		state = options.delete(:state)
+		index = options.delete(:index)
+		post('/ADirectControl.html', options) do
+			self[:"screen#{index}"] = state if state
+			:success
+		end
+	end
+end

data/modules/sony/display/{gdx_and_fwd.rb → id_talk.rb}

@@ -5,7 +5,7 @@ module Sony::Display; end
 #
 # Port: 53484
 #
-class Sony::Display::GdxAndFwd
+class Sony::Display::IdTalk
 	include ::Orchestrator::Constants
     include ::Orchestrator::Transcoder
 
@@ -16,9 +16,19 @@ class Sony::Display::GdxAndFwd
         self[:contrast_max] = 0x64
         self[:volume_min] = 0x00
         self[:volume_max] = 0x64
+
         self[:power] = false
         self[:type] = :lcd
 
+        config({
+            tokenize: proc {
+                ::UV::AbstractTokenizer.new({
+                    indicator: "\x02\x10",  # Header
+                    callback: method(:check_complete)
+                })
+            }
+        })
+
 		on_update
 	end
 
@@ -164,15 +174,14 @@ class Sony::Display::GdxAndFwd
 	}
 	
 
-	def received(data, resolve, command)		# Data is default received as a string
+	def received(byte_str, resolve, command)		# Data is default received as a string
 		logger.debug "sony display sent: 0x#{byte_to_hex(data)}"
 
-		idt_header = data[0..1]
-		idt_community = data[2..5]
-		idt_command = str_to_array(data[6..9])
-		resp = str_to_array(data[10..-1])
+		data = str_to_array(byte_str)
+		idt_command = data[5..6]
+		resp = data[8..-1]
 
-		if idt_command[0] == 0x01
+		if data[4] == 0x01
 			# resp is now equal to the unit control codes
 
 			type = RESP[resp[1]]
@@ -216,6 +225,28 @@ class Sony::Display::GdxAndFwd
 	
 	
 	protected
+
+
+	# Called by the Abstract Tokenizer to confirm we have the
+	# whole message.
+    def check_complete(byte_str)
+    	bytes = str_to_array(byte_str)
+
+    	# Min message length is 8 bytes
+        return false if bytes.length < 8
+
+        # Check we have the data
+        data = bytes[8..-1]
+        if data.length == bytes[7]
+        	return true
+        elsif data.length > bytes[7]
+        	# Let the tokeniser know we only want the following number of bytes
+        	return 7 + bytes[7]
+        end
+
+        # Still waiting on data
+        return false
+    end
 	
 	
 	def do_poll(*args)

data/modules/sony/projector/pj_talk.rb

@@ -0,0 +1,300 @@
+module Sony; end
+module Sony::Projector; end
+
+
+#
+# Port: 53484
+#
+class Sony::Projector::PjTalk
+	include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+
+	def on_load
+		self[:brightness_min] = 0x00
+        self[:brightness_max] = 0x64
+        self[:contrast_min] = 0x00
+        self[:contrast_max] = 0x64
+
+        self[:power] = false
+        self[:type] = :projector
+
+		on_update
+		config({
+            tokenize: proc {
+                ::UV::AbstractTokenizer.new({
+                    indicator: "\x02\x0a",  # Header
+                    callback: method(:check_complete)
+                })
+            }
+        })
+
+		defaults({
+			delay_on_receive: 200
+		})
+	end
+
+	def on_update
+		# Default community value is SONY - can be changed in displays settings
+		@community = str_to_array(setting(:community) || 'SONY')
+	end
+	
+
+	def connected
+		@polling_timer = schedule.every('60s', method(:do_poll))
+	end
+
+	def disconnected
+		@polling_timer.cancel unless @polling_timer.nil?
+        @polling_timer = nil
+	end
+	
+	
+	#
+	# Power commands
+	#
+	def power(state)
+		if is_affirmative?(state)
+			do_send(:set, :power_on, name: :power, delay_on_receive: 3000)
+			logger.debug "-- sony display requested to power on"
+		else
+			do_send(:set, :power_off, name: :power, delay_on_receive: 3000)
+			logger.debug "-- sony display requested to power off"
+		end
+
+		# Request status update
+		power?
+	end
+
+	def power?(options = {}, &block)
+		options[:emit] = block if block_given?
+		options[:priority] = 0
+		do_send(:get, :power_status, options)
+	end
+	
+	
+	
+	#
+	# Input selection
+	#
+	INPUTS = {
+		:vga => [0x00, 0x03],
+		:dvi => [0x00, 0x04],
+		:hdmi => [0x00, 0x05]
+	}
+	INPUTS.merge!(INPUTS.invert)
+	
+	
+	def switch_to(input)
+		input = input.to_sym
+		return unless INPUTS.has_key? input
+		
+		do_send(:set, :input, INPUTS[input], delay_on_receive: 500)
+		logger.debug "-- sony projector, requested to switch to: #{input}"
+		
+		input?
+	end
+
+	def input?
+		do_send(:get, :input, {:priority => 0})
+	end
+	
+	
+	#
+	# Mute Audio and Video
+	#
+	def mute(val = true)
+		logger.debug "-- sony projector, requested to mute"
+
+		actual = is_affirmative?(val) ? [0x00, 0x01] : [0x00, 0x00]
+		do_send(:set, :mute, actual, delay_on_receive: 500)
+	end
+
+	def unmute
+		logger.debug "-- sony projector, requested to unmute"
+		mute(false)
+	end
+
+	def mute?
+		do_send(:get, :mute, {:priority => 0})
+	end
+
+
+	#
+	# 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
+	#
+	[:contrast, :brightness, :color, :hue, :sharpness].each do |command|
+		# Query command
+		define_method :"#{command}?" do
+			do_send(:get, command, {:priority => 0})
+		end
+
+		# Set value command
+		define_method command do |level|
+			level = in_range(level, 0x64)
+			do_send(:set, command, [0x00, level])
+			__send__(:"#{command}?")
+		end
+	end
+
+	
+	ERRORS = {
+		0x00 => 'No Error'.freeze,
+		0x01 => 'Lamp Error'.freeze,
+		0x02 => 'Fan Error'.freeze,
+		0x04 => 'Cover Error'.freeze,
+		0x08 => 'Temperature Error'.freeze,
+		0x10 => 'D5V Error'.freeze,
+		0x20 => 'Power Error'.freeze,
+		0x40 => 'Warning Error'.freeze
+	}
+
+
+	def received(byte_str, resolve, command)		# Data is default received as a string
+		# Remove community string (useless)
+		logger.debug  "sony proj sent: 0x#{byte_to_hex(byte_str[4..-1])}"
+
+		data = str_to_array(byte_str)
+		pjt_command = data[5..6]
+		pjt_length = data[7]
+		pjt_data = data[8..-1]
+
+		if data[4] == 0x01
+			case COMMANDS[pjt_command]
+			when :power_on
+				self[:power] = On
+			when :power_off
+				self[:power] = Off
+			else
+				# Same switch however now we know there is data
+				if pjt_length > 0
+					case COMMANDS[pjt_command]
+					when :power_status
+						case pjt_data[-1]
+						when 0, 8
+							self[:warming] = self[:cooling] = self[:power] = false
+						when 1, 2
+							self[:cooling] = false
+							self[:warming] = self[:power] = true
+						when 3
+							self[:power] = true
+							self[:warming] = self[:cooling] = false
+						when 4, 5, 6, 7
+							self[:cooling] = true
+							self[:warming] = self[:power] = false
+						end
+
+						if self[:warming] || self[:cooling]
+							schedule.in '10s' do
+								power?
+							end
+						end
+					when :mute
+						self[:mute] = pjt_data[-1] == 1
+					when :input
+						self[:input] = INPUTS[pjt_data]
+					when :contrast, :brightness, :color, :hue, :sharpness
+						self[COMMANDS[pjt_command]] = pjt_data[-1]
+					when :error_status
+
+					end
+				end
+			end
+		else
+			# Command failed..
+			self[:last_error] = pjt_data
+			logger.debug "Command #{pjt_command} failed with Major 0x#{pjt_data[0].to_s(16)} and Minor 0x#{pjt_data[1].to_s(16)}"
+			return :abort
+		end
+
+		:success
+	end
+
+	
+	protected
+
+
+	# Called by the Abstract Tokenizer to confirm we have the
+	# whole message.
+    def check_complete(byte_str)
+    	bytes = str_to_array(byte_str)
+
+    	# Min message length is 8 bytes
+        return false if bytes.length < 8
+
+        # Check we have the data
+        data = bytes[8..-1]
+        if data.length == bytes[7]
+        	return true
+        elsif data.length > bytes[7]
+        	# Let the tokeniser know we only want the following number of bytes
+        	return 7 + bytes[7]
+        end
+
+        # Still waiting on data
+        return false
+    end
+	
+	
+	def do_poll(*args)
+		power?({:priority => 0}) do
+			if self[:power]
+				input?
+				mute?
+				do_send(:get, :error_status, {:priority => 0})
+			end
+		end
+	end
+
+	# Constants as per manual page 13
+	# version, category
+	PjTalk_Header = [0x02, 0x0a]
+
+
+	# request, category, command
+	COMMANDS = {
+		power_on: [0x17, 0x2E],
+		power_off: [0x17, 0x2F],
+		input: [0x00, 0x01],
+		mute: [0x00, 0x30],
+
+		error_status: [0x01, 0x01],
+		power_status: [0x01, 0x02],
+
+		contrast: [0x00, 0x10],
+		brightness: [0x00, 0x11],
+		color: [0x00, 0x12],
+		hue: [0x00, 0x13],
+		sharpness: [0x00, 0x14],
+	}
+	COMMANDS.merge!(COMMANDS.invert)
+
+
+	def do_send(getset, command, param = nil, options = {})
+		# Check for missing params
+		if param.is_a? Hash
+			options = param
+			param = nil
+		end
+
+		reqres = getset == :get ? [0x01] : [0x00]
+
+		# Control + Mode
+		if param.nil?
+			options[:name] = command if options[:name].nil?
+			cmd = COMMANDS[command] + [0x00]
+		else
+			options[:name] = :"#{command}_req" if options[:name].nil?
+			if !param.is_a?(Array)
+				param = [param]
+			end
+			cmd = COMMANDS[command] + [param.length] + param
+		end
+
+		# Build the IDTalk header         # set request every time?
+		pjt_cmd = PjTalk_Header + @community + reqres + cmd
+
+		send(pjt_cmd, options)
+	end
+end