aca-device-modules 1.0.0

data/modules/biamp/nexia.rb

@@ -0,0 +1,125 @@
+# encoding: US-ASCII
+
+module Biamp; end
+
+# TELNET port 23
+
+class Biamp::Nexia
+	include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+	
+	def on_load
+		self[:fader_min] = -36		# specifically for tonsley
+		self[:fader_max] = 12
+
+		# max +12
+		# min -100
+
+		config({
+			tokenize: true,
+			delimiter: /\xFF\xFE\x01|\r\n/
+		})
+	end
+	
+	def on_unload
+	end
+	
+	def on_update
+	end
+	
+	
+	def connected
+		send("\xFF\xFE\x01")	# Echo off
+		do_send('GETD', 0, 'DEVID')
+		
+		@polling_timer = schedule.every('60s') do
+			do_send('GETD', 0, 'DEVID')
+		end
+	end
+	
+	def disconnected
+		@polling_timer.cancel unless @polling_timer.nil?
+		@polling_timer = nil
+	end
+	
+	
+	def preset(number)
+		#
+		# Recall Device 0 Preset number 1001
+		# Device Number will always be 0 for Preset strings
+		# 1001 == minimum preset number
+		#
+		do_send('RECALL', 0, 'PRESET', number)
+	end
+	
+	def fader(fader_id, level)
+		# value range: -100 ~ 12
+		do_send('SETD', self[:device_id], 'FDRLVL', fader_id, 1, level)
+	end
+	
+	def mute(fader_id)
+		do_send('SETD', self[:device_id], 'FDRMUTE', fader_id, 1, 1)
+	end
+	
+	def unmute(fader_id)
+		do_send('SETD', self[:device_id], 'FDRMUTE', fader_id, 1, 0)
+	end
+
+	def query_fader(fader_id)
+		send("GET #{self[:device_id]} FDRLVL #{fader_id} 1 \n") do |data|
+			if data == "-ERR"
+				:abort
+			else
+				self[:"fader_#{fader_id}"] = data.to_i
+				:success
+			end
+		end
+	end
+
+	def query_mute(fader_id)
+		send("GET #{self[:device_id]} FDRMUTE #{fader_id} 1 \n") do |data|
+			if data == "-ERR"
+				:abort
+			else
+				self[:"fader_#{fader_id}_mute"] = data.to_i == 1
+				:success
+			end
+		end
+	end
+	
+	
+	def received(data, resolve, command)
+		data = data.split(' ')
+		
+		if data.length == 1
+			if data[-1] == "-ERR"
+				logger.debug "Nexia Invalid Command sent #{command[:data]}" if !!command
+				return :abort
+			end
+			return :success	# data[-1] == "+OK" || data == ""	# Echo off
+		end
+		
+		unless data[2].nil?
+			case data[2].to_sym
+			when :FDRLVL
+				self[:"fader_#{data[3]}"] = data[-2].to_i
+			when :FDRMUTE
+				self[:"fader_#{data[3]}_mute"] = data[-2] == "1"
+			when :DEVID
+				self[:device_id] = data[-2].to_i
+			end
+		end
+		
+		return :success
+	end
+	
+	
+	
+	private
+	
+	
+	def do_send(*args)
+		send("#{args.join(' ')}\n")
+	end
+end
+

data/modules/bss/blu100.rb

@@ -0,0 +1,265 @@
+module Bss; end
+
+# TCP port 1023
+
+class Bss::Blu100
+    include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+    
+	def on_load
+        defaults({
+            :wait => false
+        })
+        config({
+            tokenize: true,
+            delimiter: "\x03",
+            indicator: "\x02"
+        })
+	end
+	
+	def on_unload
+	end
+	
+	def on_update
+	end
+
+    def connected
+        subscribe_percent(1, 60000)
+        @polling_timer = schedule.every('150s') do  # Every 2.5 min
+            subscribe_percent(1, 60000)             # Request the level of Hybrid I/O Card A
+        end                                         # This works to maintain the connection
+    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
+
+
+    OPERATION_CODE = {
+        :set_state => 0x88,
+        :subscribe_state => 0x89,
+        :unsubscribe_state => 0x8A,
+        :venue_preset => 0x8B,
+        :param_preset => 0x8C,
+        :set_percent => 0x8D,
+        :subscribe_percent => 0x8E,
+        :unsubscribe_percent => 0x8F,
+        :set_relative_percent => 0x90
+    }
+    OPERATION_CODE.merge!(OPERATION_CODE.invert)
+
+
+    def preset(number)
+        number = number.to_i
+
+        do_send([OPERATION_CODE[:venue_preset]] + number_to_data(number))
+    end
+    
+
+    #
+    # Level controls
+    #
+    def fader(fader, percent)
+        percent = percent.to_i
+        percent = 6553600 if percent > 6553600
+        percent = 0 if percent < 0
+
+        percent = number_to_data(percent)
+
+        do_send([OPERATION_CODE[:set_percent]] + NODE + VIRTUAL + number_to_object(fader.to_i) + CONTROLS[:gain] + percent)
+        subscribe_percent(fader)
+    end
+
+    def mute(fader)
+        do_send([OPERATION_CODE[:set_state]] + NODE + VIRTUAL + number_to_object(fader.to_i) + CONTROLS[:mute] + number_to_data(1))
+        subscribe_state(fader)
+    end
+
+    def unmute(fader)
+        do_send([OPERATION_CODE[:set_state]] + NODE + VIRTUAL + number_to_object(fader.to_i) + CONTROLS[:mute] + number_to_data(0))
+        subscribe_state(fader)
+    end
+
+
+    def query_fader(fader_id)
+        subscribe_percent(fader_id)
+    end
+
+    def query_mute(fader_id)
+        subscribe_state(fader_id)
+    end
+
+
+    #
+    # Percent controls for relative values
+    #
+    def subscribe_percent(fader, rate = 0, control = CONTROLS[:gain])   # rate must be 0 for non meter controls
+        fader = number_to_object(fader.to_i)
+        rate = number_to_data(rate.to_i)
+
+        do_send([OPERATION_CODE[:subscribe_percent]] + NODE + VIRTUAL + fader + control + rate)
+    end
+
+    def unsubscribe_percent(fader, control = CONTROLS[:gain])   # rate must be 0 for non meter controls
+        fader = number_to_object(fader.to_i)
+        rate = number_to_data(0)
+
+        do_send([OPERATION_CODE[:unsubscribe_percent]] + NODE + VIRTUAL + fader + control + rate)
+    end
+
+    #
+    # State controls are for discrete values
+    #
+    def subscribe_state(fader, rate = 0, control = CONTROLS[:mute]) # 1000 == every second
+        fader = number_to_object(fader.to_i)
+        rate = number_to_data(rate.to_i)
+
+        do_send([OPERATION_CODE[:subscribe_state]] + NODE + VIRTUAL + fader + control + rate)
+    end
+
+    def unsubscribe_state(fader, control = CONTROLS[:mute]) # 1000 == every second
+        fader = number_to_object(fader.to_i)
+        rate = number_to_data(0)
+
+        do_send([OPERATION_CODE[:unsubscribe_state]] + NODE + VIRTUAL + fader + control + rate)
+    end
+
+
+    def received(data, resolve, command)
+        #
+        # Grab the message body
+        #
+        data = data.split("\x02")
+        data = str_to_array(data[-1])
+
+        #
+        # Unescape any control characters
+        #
+        message = []
+        found = false
+        data.each do |byte|
+            if found
+                found = false
+                message << (byte - 0x80)
+            elsif RESERVED_CHARS.include? byte
+                found = true
+            else
+                message << byte
+            end
+        end
+
+        #
+        # Process the response
+        #
+        if check_checksum(message)
+            logger.debug "Blu100 sent 0x#{byte_to_hex(array_to_str(message))}"
+
+            data = byte_to_hex(array_to_str(message[-4..-1])).to_i(16)
+            type = message[0]       # Always sent
+
+            node = message[1..2]
+            vi = message[3]
+            obj = message[4..6]
+            cntrl = message[7..8]
+
+            case OPERATION_CODE[type]
+            when :set_state   # This is the mute response
+                obj = byte_to_hex(array_to_str(obj)).to_i(16)
+                if CONTROLS[cntrl] == :mute
+                    self[:"fader_#{obj}_mute"] = data == 1
+                else
+                    self[:"fader_#{obj}"] = data
+                end
+            when :subscribe_state
+            when :unsubscribe_state
+            when :venue_preset
+            when :param_preset
+            when :set_percent   # This is the fader response
+                obj = byte_to_hex(array_to_str(obj)).to_i(16)
+                self[:"fader_#{obj}"] = data
+            when :subscribe_percent
+            when :unsubscribe_percent
+            when :set_relative_percent
+            end
+
+            return :success
+        else
+            logger.warn "Blu100 Checksum error: 0x#{byte_to_hex(array_to_str(message))}"
+            return :failed
+        end
+    end
+
+
+    protected
+
+
+    def number_to_data(num)
+        str_to_array(hex_to_byte(num.to_s(16).upcase.rjust(8, '0')))
+    end
+
+    def number_to_object(num)
+        str_to_array(hex_to_byte(num.to_s(16).upcase.rjust(6, '0')))
+    end
+
+
+    RESERVED_CHARS = [0x02, 0x03, 0x06, 0x15, 0x1B]
+    NODE = [0,0]    # node we are connected to
+    VIRTUAL = [3]   # virtual device is always 3 for audio devices
+
+    CONTROLS = {
+        :gain => [0,0],
+        :mute => [0,1]
+    }
+    CONTROLS.merge!(CONTROLS.invert)
+
+
+    def check_checksum(data)
+        #
+        # Loop through the second to the second last element
+        #   Delimiter is removed automatically
+        #
+        check = 0
+        data[0..-2].each do |byte|
+            check = check ^ byte
+        end
+        return check == data.pop    # Check the check sum equals the last element
+    end
+
+    
+
+    def do_send(command, options = {})
+        #
+        # build checksum
+        #
+        check = 0
+        command.each do |byte|
+            check = check ^ byte
+        end
+        command = command + [check]
+
+        #
+        # Substitute reserved characters
+        #
+        substituted = []
+        command.each do |byte|
+            if RESERVED_CHARS.include? byte
+                substituted << 0x1B << (byte + 0x80)
+            else
+                substituted << byte
+            end
+        end
+
+        #
+        # Add the control characters
+        #
+        substituted.unshift 0x02
+        substituted << 0x03
+
+        send(substituted, options)
+    end
+end

data/modules/clipsal/c_bus.rb

@@ -0,0 +1,256 @@
+module Clipsal; end
+
+
+#
+# Common Headers
+# 	0x03 == point - point -multipoint, low pri
+# 	0x05 == point - multipoint, low pri
+# 	0x06 == point - point, low pri
+#
+# 	11xxx110  (x == reserved)
+# 	-- Priority, 11 == high, 00 == low
+# 	     --- Destination, 011 = P-P-M, 101 = P-M, 110 = P-P
+#
+#
+# Commands are formatted as: \ + Header + 00 + Data + checksum + <cr>
+#
+# Turn group on \ + 05 (MP header) + 38 (lighting) + 00 + 79 (group on) + XX (group number) + checksum + <cr>
+# Turn group off \ + 05 (MP header) + 38 (lighting) + 00 + 01 (group off) + XX (group number) + checksum + <cr>
+# Ramp a group \ + 05 (MP header) + 38 (lighting) + 00 + 79 (group on) + XX (group number) + checksum + <cr>
+#
+
+
+
+class Clipsal::CBus
+	include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+	
+	def on_load
+		defaults({
+			:wait => false
+		})
+
+		config({
+			tokenize: true,
+			delimiter: "\x0D"
+		})
+	end
+	
+	def on_unload
+	end
+	
+	def on_update
+		
+	end
+	
+	
+	def connected
+		send("|||\r", :wait => false)	# Ensure we are in smart mode
+		@polling_timer = schedule.every('60s') do
+			logger.debug "-- Polling CBUS"
+			send("|||\r", :wait => false)	# Ensure we are in smart mode
+		end
+	end
+	
+	def disconnected
+		@polling_timer.cancel unless @polling_timer.nil?
+		@polling_timer = nil
+	end
+	
+	
+	def lighting(group, state, application = 0x38)
+		group = group & 0xFF
+		application = application & 0xFF
+		
+		command = [0x05, application, 0x00]
+		if [On, 1, :on, 'on'].include?(state)
+			state = On
+			command << 0x79 # Group on
+		else
+			state = Off
+			command << 0x01 # Group off
+		end
+		command << group
+
+		self["lighting_group_#{group}"] = state
+		
+		do_send(command)
+	end
+	
+	
+	def lighting_ramp(group, level, rate = 0b0001, application = 0x38)
+		
+		#
+		# rates:
+		# => 0 == instant
+		# => 1 == 4sec
+		# => 2 == 8sec etc
+		#
+		rate = ((rate & 0x0F) << 3) | 0b010	# The command is structured as: 0b0 xxxx 010 where xxxx == rate
+		group = group & 0xFF
+		level = level & 0xFF
+		application = application & 0xFF
+		
+		lighting_term_ramp(group)
+		command = [0x05, application, 0x00, rate, group, level]
+		
+		do_send(command)
+	end
+
+
+
+	def blinds(group, action, application = 0x38)
+		group = group & 0xFF
+		application = application & 0xFF
+
+		command = [0x05, application, 0x00]
+		if is_affirmative?(action)
+			action = Down
+			command += [0x1A, group, 0x00]
+		else
+			command += [0x02, group]
+
+			if is_negatory?(action)
+				action = Up
+				command << 0xFF
+			else
+				# Stop (need to confirm this)
+				command << 0x05
+			end
+		end
+
+		do_send(command)
+	end
+	
+	
+	def trigger(group, action)
+		action = action.to_i
+		group = group.to_i
+		
+		group = group & 0xFF
+		action = action & 0xFF
+		command = [0x05, 0xCA, 0x00, 0x02, group, action]
+		
+		self["trigger_group_#{group}"] = action
+
+		do_send(command)
+	end
+	
+	
+	def trigger_kill(group)
+		group = group.to_i
+		
+		group = group & 0xFF
+		command = [0x05, 0xCA, 0x00, 0x01, group]
+		do_send(command)
+	end
+	
+	
+	def received(data, resolve, command)
+		# Debug here will sometimes have the \n char
+		# This is removed by the hex_to_byte function
+		logger.debug "CBus sent #{data}"
+		
+		data = str_to_array(hex_to_byte(data))
+		
+		if !check_checksum(data)
+			logger.debug "CBus checksum failed"
+			return :failed
+		end
+
+		# We are only looking at Point -> MultiPoint commands
+		return if data[0] != 0x05
+		# 0x03 == Point -> Point -> MultiPoint
+		# 0x06 == Point -> Point
+		
+		application = data[2]	# The application being referenced
+		commands = data[4..-2]	# Remove the header + checksum
+		
+		while commands.length > 0
+			current = commands.shift
+			
+			case application
+			when 0xCA			# Trigger group
+				case current
+				when 0x02			# Trigger Event (ex: 0504CA00 020101 29)
+					self["trigger_group_#{commands.shift}"] = commands.shift	# Action selector
+				when 0x01			# Trigger Min
+					self["trigger_group_#{commands.shift}"] = 0
+				when 0x79			# Trigger Max
+					self["trigger_group_#{commands.shift}"] = 0xFF
+				when 0x09			# Indicator Kill (ex: 0504CA00 0901 23)
+					commands.shift		# Group (turns off indicators of all scenes triggered by this group)
+				else
+					break	# We don't know what data is here
+				end
+			when 0x30..0x5F		# Lighting group
+				case current
+				when 0x01			# Group off (ex: 05043800 0101 0102 0103 0104 7905 33)
+					self["lighting_group_#{commands.shift}"] = Off
+				when 0x79			# Group on (ex: 05013800 7905 44)
+					self["lighting_group_#{commands.shift}"] = On
+				when 0x02 # Blinds up or stop
+					group = commands.shift
+					value = commands.shift
+					if value == 0xFF
+						self["blinds_group_#{group}"] = Up
+					elsif value == 0x05 # Value needs confirmation
+						self["blinds_group_#{group}"] = :stopped
+					end
+				when 0x1A # Blinds down
+					group = commands.shift
+					value = commands.shift
+					self["blinds_group_#{group}"] = Down if value == 0x00
+				when 0x09			# Terminate Ramp
+					commands.shift		# Group address
+				else
+					if (current & 0b10000101) == 0	# Ramp to level (ex: 05013800 0205FF BC)
+						commands.shift(2)	# Group address, level
+					else
+						break	# We don't know what data is here
+					end
+				end
+			else
+				break	# We haven't programmed this application
+			end
+		end
+		
+		return :success
+	end
+	
+	
+	protected
+	
+	
+	def lighting_term_ramp(group)
+		command = [0x05, 0x38, 0x00, 0x09, group]
+		do_send(command)
+	end
+	
+	
+	def checksum(data)
+		check = 0
+		data.each do |byte|
+			check += byte
+		end
+		check = check % 0x100
+		check = ((check ^ 0xFF) + 1) & 0xFF
+		return check
+	end
+	
+	def check_checksum(data)
+		check = 0
+		data.each do |byte|
+			check += byte
+		end
+		return (check % 0x100) == 0x00
+	end
+	
+	
+	def do_send(command, options = {})
+		string = byte_to_hex(array_to_str(command << checksum(command))).upcase
+		send("\\#{string}\r", options)
+		#logger.debug "CBus module sent #{string}"
+	end
+end
+