aca-device-modules 1.0.0

data/modules/extron/switcher/dxp.rb

@@ -0,0 +1,249 @@
+module Extron; end
+module Extron::Switcher; end
+
+
+# :title:Extron Digital Matrix Switchers
+# NOTE:: Very similar to the XTP!! Update both
+#
+# Status information avaliable:
+# -----------------------------
+#
+# (built in)
+# connected
+#
+# (module defined)
+# video_inputs
+# video_outputs
+# audio_inputs
+# audio_outputs
+#
+# video1 => input (video)
+# video2
+# video3
+# video1_muted => true
+#
+# audio1 => input
+# audio1_muted => true
+# 
+#
+# (Settings)
+# password
+#
+
+
+class Extron::Switcher::Dxp
+	include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+
+
+	def on_load
+		#
+		# Setup constants
+		#
+		defaults({
+			:wait => false
+		})
+		config({
+			:clear_queue_on_disconnect => true	# Clear the queue as we may need to send login
+		})
+	end
+
+	def connected
+		@polling_timer = schedule.every('2m') do
+			logger.debug "-- Extron Maintaining Connection"
+			send('Q', :priority => 0)	# Low priority poll to maintain connection
+		end
+	end
+
+	def disconnected
+		#
+		# Disconnected may be called without calling connected
+		#	Hence the check if timer is nil here
+		#
+		@polling_timer.cancel unless @polling_timer.nil?
+		@polling_timer = nil
+	end
+
+
+	def direct(string)
+		send(string, :wait => false)
+	end
+
+
+	#
+	# No need to wait as commands can be chained
+	#
+	def switch(map)
+		map.each do |input, outputs|
+			input = input.to_s if input.is_a?(Symbol)
+			input = input.to_i if input.is_a?(String)
+
+			outputs = [outputs] unless outputs.is_a?(Array)
+			command = ''
+			outputs.each do |output|
+				command += "#{input}*#{output}!"
+			end
+			send(command)
+		end
+	end
+
+	def switch_video(map)
+		map.each do |input, outputs|
+			input = input.to_s if input.is_a?(Symbol)
+			input = input.to_i if input.is_a?(String)
+			
+			
+			outputs = [outputs] unless outputs.is_a?(Array)
+			command = ''
+			outputs.each do |output|
+				command += "#{input}*#{output}%"
+			end
+			send(command)
+		end
+	end
+
+	def switch_audio(map)
+		map.each do |input, outputs|
+			input = input.to_s if input.is_a?(Symbol)
+			input = input.to_i if input.is_a?(String)
+			
+			outputs = [outputs] unless outputs.is_a?(Array)
+			command = ''
+			outputs.each do |output|
+				command += "#{input}*#{output}$"
+			end
+			send(command)
+		end
+	end
+
+	def mute_video(outputs)
+		outputs = [outputs] unless outputs.is_a?(Array)
+		command = ''
+		outputs.each do |output|
+			command += "#{output}*1B"
+		end
+		send(command)
+	end
+
+	def unmute_video(outputs)
+		outputs = [outputs] unless outputs.is_a?(Array)
+		command = ''
+		outputs.each do |output|
+			command += "#{output}*0B"
+		end
+		send(command)
+	end
+
+	def mute_audio(outputs)
+		outputs = [outputs] unless outputs.is_a?(Array)
+		command = ''
+		outputs.each do |output|
+			command += "#{output}*1Z"
+		end
+		send(command)
+	end
+
+	def unmute_audio(outputs)
+		outputs = [outputs] unless outputs.is_a?(Array)
+		command = ''
+		outputs.each do |output|
+			command += "#{output}*0Z"
+		end
+		send(command)
+	end
+
+	def set_preset(number)
+		send("#{number},")
+	end
+
+	def recall_preset(number)
+		send("#{number}.")
+	end
+
+
+	#def response_delimiter
+	#	[0x0D, 0x0A]	# Used to interpret the end of a message
+	#end
+
+
+	#
+	# Sends copyright information
+	# Then sends password prompt
+	#
+	def received(data, resolve, command)
+		logger.debug "Extron Matrix sent #{data}"
+
+		if command.nil? && data =~ /Copyright/i
+			pass = setting(:password)
+			if pass.nil?
+				device_ready
+			else
+				do_send(pass)		# Password set
+			end
+		elsif data =~ /Login/i
+			device_ready
+		elsif command.present? && command[:command] == :information
+			data = data.split(' ')
+			video = data[0][1..-1].split('X')
+			self[:video_inputs] = video[0].to_i
+			self[:video_outputs] = video[1].to_i
+
+			audio = data[1][1..-1].split('X')
+			self[:audio_inputs] = audio[0].to_i
+			self[:audio_outputs] = audio[1].to_i
+		else
+			case data[0..1].to_sym
+			when :Am	# Audio mute
+				data = data[3..-1].split('*')
+				self["audio#{data[0].to_i}_muted"] = data[1] == '1'
+			when :Vm	# Video mute
+				data = data[3..-1].split('*')
+				self["video#{data[0].to_i}_muted"] = data[1] == '1'
+			when :In	# Input to all outputs
+				data = data[2..-1].split(' ')
+				input = data[0].to_i
+				if data[1] =~ /(All|RGB|Vid)/
+					for i in 1..self[:video_outputs]
+						self["video#{i}"] = input
+					end
+				end
+				if data[1] =~ /(All|Aud)/
+					for i in 1..self[:audio_outputs]
+						self["audio#{i}"] = input
+					end
+				end
+			when :Ou	# Output x to input y
+				data = data[3..-1].split(' ')
+				output = data[0].to_i
+				input = data[1][2..-1].to_i
+				if data[2] =~ /(All|RGB|Vid)/
+					self["video#{output}"] = input
+				end
+				if data[2] =~ /(All|Aud)/
+					self["audio#{output}"] = input
+				end
+			else
+				if data == 'E22'	# Busy! We should retry this one
+					command[:delay_on_receive] = 1 unless command.nil?
+					return :failed
+				end
+			end
+		end
+
+		return :success
+	end
+
+
+	private
+
+
+	def device_ready
+		send("I", :wait => true, :command => :information)
+		do_send("\e3CV", :wait => true)	# Verbose mode and tagged responses
+	end
+
+	def do_send(data, options = {})
+		send(data << 0x0D, options)
+	end
+end
+

data/modules/global_cache/gc100.rb

@@ -0,0 +1,167 @@
+module GlobalCache; end
+
+
+class GlobalCache::Gc100
+    include ::Orchestrator::Constants
+
+
+    def on_load
+        self[:num_relays] = 0
+        self[:num_ir] = 0
+
+        config({
+            tokenize: true,
+            delimiter: "\x0D"
+        })
+    end
+    
+    def on_update
+        self[:config_indexed] = false
+    end
+    
+    #
+    # Config maps the GC100 into a linear set of ir and relays so models can be swapped in and out
+    #  config => {:relay => {0 => '2:1',1 => '2:2',2 => '2:3',3 => '3:1'}} etc
+    #
+    def connected
+        unless self[:config_indexed]
+            self[:config] = {}
+            do_send('getdevices', :max_waits => 100)
+        end
+        
+        @polling_timer = schedule.every('60s') do
+            logger.debug "-- Polling GC100"
+            do_send("get_NET,0:1", :priority => 0)    # Low priority sent to maintain the connection
+        end
+    end
+    
+    def disconnected
+        @polling_timer.cancel unless @polling_timer.nil?
+        @polling_timer = nil
+    end
+    
+    
+    
+    def relay(index, state)
+        if index < self[:num_relays]
+            connector = self[:config][:relay][index]
+            if is_affirmative?(state)
+                state = 1
+            else
+                state = 0
+            end
+            
+            do_send("setstate,#{connector},#{state}")
+        else
+            logger.warn "Attempted to set relay on GlobalCache that does not exist: #{index}"
+        end
+    end
+    
+    def ir(index, command, options = {})
+        do_send("sendir,1:#{index},#{command}", options)
+    end
+    
+    
+    def relay_status?(index, &block)
+        if index < self[:num_relays]
+            connector = self[:config][:relay][index]
+            do_send("getstate,#{connector}", {:emit => {"relay#{index}".to_sym => block}})
+        else
+            logger.warn "Attempted to check IO on GlobalCache that does not exist: #{index}"
+        end
+    end
+    
+    def io_status?(index, &block)
+        if index < self[:num_ir]
+            connector = self[:config][:ir][index]
+            do_send("getstate,#{connector}", {:emit => {"ir#{index}".to_sym => block}})
+        else
+            logger.warn "Attempted to check IO on GlobalCache that does not exist: #{index}"
+        end
+    end
+    
+    
+    
+    def received(data, command)
+        logger.debug "GlobalCache sent #{data}"
+        data = data.split(',')
+        
+        case data[0].to_sym
+        when :state, :statechange
+            type, index = self[:config][data[1]]
+            self["#{type}#{index}"] = data[2] == '1'    # Is relay index on?
+        when :device
+            address = data[1]
+            number, type = data[2].split(' ')        # The response was "device,2,3 RELAY"
+            
+            type = type.downcase.to_sym
+            
+            update_status(:config) do |value|
+                value ||= {}
+                value[type] ||= {}
+                current = value[type].length
+                
+                dev_index = 1                
+                (current..(current + number.to_i - 1)).each do |index|
+                    port = "#{address}:#{dev_index}"
+                    value[type][index] = port
+                    value[port] = [type, index]
+                    dev_index += 1
+                end
+                
+                value
+            end
+            return :ignore
+            
+        when :endlistdevices
+            self[:config_indexed] = true
+            config = self[:config]
+            self[:num_relays] = config[:relay].length unless config[:relay].nil?
+            self[:num_ir] = config[:ir].length unless config[:ir].nil?
+            
+            return :success
+        end
+        
+        
+        if data.length == 1
+            error = case data[0].split(' ')[1].to_i
+                when 1 then 'Command was missing the carriage return delimiter'
+                when 2 then 'Invalid module address when looking for version'
+                when 3 then 'Invalid module address'
+                when 4 then 'Invalid connector address'
+                when 5 then 'Connector address 1 is set up as "sensor in" when attempting to send an IR command'
+                when 6 then 'Connector address 2 is set up as "sensor in" when attempting to send an IR command'
+                when 7 then 'Connector address 3 is set up as "sensor in" when attempting to send an IR command'
+                when 8 then 'Offset is set to an even transition number, but should be set to an odd transition number in the IR command'
+                when 9 then 'Maximum number of transitions exceeded (256 total on/off transitions allowed)'
+                when 10 then 'Number of transitions in the IR command is not even (the same number of on and off transitions is required)'
+                when 11 then 'Contact closure command sent to a module that is not a relay'
+                when 12 then 'Missing carriage return. All commands must end with a carriage return'
+                when 13 then 'State was requested of an invalid connector address, or the connector is programmed as IR out and not sensor in.'
+                when 14 then 'Command sent to the unit is not supported by the GC-100'
+                when 15 then 'Maximum number of IR transitions exceeded'
+                when 16 then 'Invalid number of IR transitions (must be an even number)'
+                when 21 then 'Attempted to send an IR command to a non-IR module'
+                when 23 then 'Command sent is not supported by this type of module'
+                else 'Unknown error'
+            end
+            logger.warn "GlobalCache error: #{error}\nFor command: #{command[:data]}"
+            return :failed
+        end
+        
+        return :success
+    end
+    
+    
+    protected
+    
+    
+    def do_send(command, options = {})
+        #logger.debug "-- GlobalCache, sending: #{command}"
+        
+        command << 0x0D
+        
+        send(command, options)
+    end
+end
+

data/modules/kramer/switcher/vs_hdmi.rb

@@ -0,0 +1,143 @@
+module Kramer; end
+module Kramer::Switcher; end
+
+
+# :title:Kramer video switches
+#
+# Status information avaliable:
+# -----------------------------
+#
+# (built in)
+# connected
+#
+# (module defined)
+# video_inputs
+# video_outputs
+#
+# video1 => input
+# video2
+# video3
+#
+
+#
+# NOTE:: These devices should be marked as make and break!
+#
+
+class Kramer::Switcher::VsHdmi
+	include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+	
+	def on_load
+		
+		#
+		# Setup constants
+		#
+		self[:limits_known] = false
+		
+		defaults({
+			:wait => false
+		})
+
+		config = ({
+			:inactivity_timeout => 10000	# We wait 10 seconds before the connection is broken (make and break)
+		})
+	end
+	
+	def connected
+		#
+		# Get current state of the switcher
+		#
+		get_machine_type
+	end
+
+	
+	COMMANDS = {
+		:reset_video => 0,
+		:switch_video => 1,
+		:status_video => 5,
+		:define_machine => 62,
+		:identify_machine => 61
+	}
+	
+	
+	#
+	# Starting at input 1
+	#
+	def switch(map)
+				# instr, inp,  outp, machine number
+				# Switch video
+		command = [1, 0x80, 0x80, 0xFF]
+		
+		map.each do |input, outputs|
+			outputs = [outputs] unless outputs.class == Array
+			input = input.to_s if input.class == Symbol
+			input = input.to_i if input.class == String
+			outputs.each do |output|
+				command[1] = 0x80 + input
+				command[2] = 0x80 + output
+				outname = :"video#{output}"
+				send(command, name: outname)
+				self[outname] = input
+			end
+		end
+	end
+	alias :switch_video :switch
+	
+	def received(data, resolve, command)
+		logger.debug "Kramer sent 0x#{byte_to_hex(data)}"
+		
+		data = str_to_array(data)
+		
+		return nil if data[0] & 0b1000000 == 0	# Check we are the destination
+
+		data[1] = data[1] & 0b1111111	# input
+		data[2] = data[2] & 0b1111111	# output
+
+		case data[0] & 0b111111
+		when COMMANDS[:define_machine]
+			if data[1] == 1
+				self[:video_inputs] = data[2]
+			elsif data[1] == 2
+				self[:video_outputs] = data[2]
+			end
+			self[:limits_known] = true	# Set here in case unsupported
+		when COMMANDS[:status_video]
+			if data[2] == 0 # Then data[1] has been applied to all the outputs
+				logger.debug "Kramer switched #{data[1]} -> All"
+				
+				(1..self[:video_outputs]).each do |i|
+					self["video#{i}"] = data[1]
+				end
+			else
+				self["video#{data[2]}"] = data[1]
+				
+				logger.debug "Kramer switched #{data[1]} -> #{data[2]}"
+				
+				#
+				# As we may not know the max number of inputs if get machine type didn't work
+				#
+				self[:video_inputs] = data[1] if data[1] > self[:video_inputs]
+				self[:video_outputs] = data[2] if data[2] > self[:video_outputs]
+			end
+		when COMMANDS[:identify_machine]
+			logger.debug "Kramer switcher protocol #{data[1]}.#{data[2]}"
+		end
+		
+		return :success
+	end
+	
+	
+	private
+	
+
+	#
+	# No all switchers implement this
+	#
+	def get_machine_type
+				# id com,    video
+		command = [62, 0x81, 0x81, 0xFF]
+		send(command, name: :inputs)	# num inputs
+		command[1] = 0x82
+		send(command, name: :outputs)	# num outputs
+	end
+end