aca-device-modules 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f068e2f8fc138bd97e542fd11651670607e3c552
-  data.tar.gz: cf23a437d8f1f777527920342a759a301bc3c6aa
+  metadata.gz: 1b69086f2a1f7cedc0f6ee28a9dba6f771233396
+  data.tar.gz: 6080121ffbf65e399205c885be16959f7b7603d7
 SHA512:
-  metadata.gz: b24a834e0ed6db515937608d39d21c276d66d644f39acb47281480f96bc2730f9f23f29ba066ff532ca356f72dfffafe250a372d28bad0e31a131d83a13acd1c
-  data.tar.gz: fde92eeed5925c426fa2ced3d3c8fab4cbf3fe5ddf222f71f1cfdbc5caa739687c5f8e7cca74b50adcb05a6f3e42f6480ce0f062772726ea2f4a39b6d89dedb5
+  metadata.gz: 38add061a9db39ec6ed34d2cfb9bba11c2d7c395f0498c1f74a2089c3a606cfafc4b0e4df7f9e62b460567dbb03108cc66507b4d573fcf8cbdd654c5b10d00ee
+  data.tar.gz: 7a5c4ecc2012e09c552bb0a48f6af767d33a1e61c47a7a850463653c4d972695e2de8ba2f7e7a6fde05d59a87d65d4094684e0a0f0b02c1ab335e841987e08a9

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

@@ -1,3 +1,3 @@
 module AcaDeviceModules
-    VERSION = "1.0.3"
+    VERSION = "1.0.4"
 end

data/modules/biamp/nexia.rb

@@ -51,38 +51,59 @@ class Biamp::Nexia
 		#
 		do_send('RECALL', 0, 'PRESET', number)
 	end
+
+	# {1 => [2,3,5], 2 => [2,3,6]}, true
+	# Supports Matrix and Automixers
+	def mixer(id, inouts, mute = false)
+		value = is_affirmative?(mute) ? 
+
+		if inouts.is_a? Hash
+			inouts.each_key do |input|
+				outputs = inouts[input]
+				outs = outputs.is_a?(Array) ? outputs : [outputs]
+
+				outs.each do |output|
+					do_send('SETD', self[:device_id], 'MMMUTEXP', id, input, output, value)
+				end
+			end
+		else # assume array (auto-mixer)
+			inouts.each do |input|
+				do_send('SETD', self[:device_id], 'AMMUTEXP', id, input, value)
+			end
+		end
+	end
 	
-	def fader(fader_id, level)
+	def fader(fader_id, level, index = 1)
 		# value range: -100 ~ 12
-		do_send('SETD', self[:device_id], 'FDRLVL', fader_id, 1, level)
+		do_send('SETD', self[:device_id], 'FDRLVL', fader_id, index, level)
 	end
 	
-	def mute(fader_id, val = true)
+	def mute(fader_id, val = true, index = 1)
 		actual = val ? 1 : 0
-		do_send('SETD', self[:device_id], 'FDRMUTE', fader_id, 1, actual)
+		do_send('SETD', self[:device_id], 'FDRMUTE', fader_id, index, actual)
 	end
 	
-	def unmute(fader_id)
-		do_send('SETD', self[:device_id], 'FDRMUTE', fader_id, 1, 0)
+	def unmute(fader_id, index = 1)
+		mute(fader_id, false, index)
 	end
 
-	def query_fader(fader_id)
-		send("GET #{self[:device_id]} FDRLVL #{fader_id} 1 \n") do |data|
-			if data == "-ERR"
+	def query_fader(fader_id, index = 1)
+		send("GET #{self[:device_id]} FDRLVL #{fader_id} #{index} \n") do |data|
+			if data.start_with?('-ERR')
 				:abort
 			else
-				self[:"fader_#{fader_id}"] = data.to_i
+				self[:"fader#{fader_id}_#{index}"] = 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"
+	def query_mute(fader_id, index = 1)
+		send("GET #{self[:device_id]} FDRMUTE #{fader_id} #{index} \n") do |data|
+			if data.start_with?('-ERR')
 				:abort
 			else
-				self[:"fader_#{fader_id}_mute"] = data.to_i == 1
+				self[:"fader#{fader_id}_#{index}_mute"] = data.to_i == 1
 				:success
 			end
 		end
@@ -90,23 +111,21 @@ class Biamp::Nexia
 	
 	
 	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
+		if data.start_with?('-ERR')
+			logger.debug "Nexia returned #{data} for #{command[:data]}" if command
+			return :abort
 		end
 		
+		#--> "#SETD 0 FDRLVL 29 1 0.000000 +OK"
+		data = data.split(' ')
 		unless data[2].nil?
 			case data[2].to_sym
-			when :FDRLVL
-				self[:"fader_#{data[3]}"] = data[-2].to_i
+			when :FDRLVL, :VL
+				self[:"fader#{data[3]}_#{data[4]}"] = data[5].to_i
 			when :FDRMUTE
-				self[:"fader_#{data[3]}_mute"] = data[-2] == "1"
+				self[:"fader#{data[3]}_#{data[4]}_mute"] = data[5] == "1"
 			when :DEVID
+				# "#GETD 0 DEVID 1 "
 				self[:device_id] = data[-2].to_i
 			end
 		end
@@ -120,7 +139,7 @@ class Biamp::Nexia
 	
 	
 	def do_send(*args)
-		send("#{args.join(' ')}\n")
+		send("#{args.join(' ')} \n")
 	end
 end
 

data/modules/bss/blu100.rb

@@ -15,12 +15,15 @@ class Bss::Blu100
             delimiter: "\x03",
             indicator: "\x02"
         })
+
+        on_update
 	end
 	
 	def on_unload
 	end
 	
 	def on_update
+        @type_lookup ||= {}
 	end
 
     def connected
@@ -64,69 +67,82 @@ class Bss::Blu100
     #
     # Level controls
     #
-    def fader(fader, percent)
+    def fader(fader, percent, index = 0)
+        index_data = id_to_array(index, :gain)
+
         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)
+        do_send([OPERATION_CODE[:set_percent]] + NODE + VIRTUAL + number_to_object(fader.to_i) + index_data + 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))
+    def mute(fader, val = true, index = 1)
+        actual = val ? 1 : 0
+
+        index_data = id_to_array(index, :mute)
+
+        do_send([OPERATION_CODE[:set_state]] + NODE + VIRTUAL + number_to_object(fader.to_i) + index_data + number_to_data(actual))
         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)
+    def unmute(fader, index = 1)
+        mute(fader, false, index)
     end
 
 
-    def query_fader(fader_id)
-        subscribe_percent(fader_id)
+    def query_fader(fader_id, index = 0)
+        subscribe_percent(fader_id, index)
     end
 
-    def query_mute(fader_id)
-        subscribe_state(fader_id)
+    def query_mute(fader_id, index = 1)
+        subscribe_state(fader_id, index)
     end
 
 
     #
     # Percent controls for relative values
     #
-    def subscribe_percent(fader, rate = 0, control = CONTROLS[:gain])   # rate must be 0 for non meter controls
+    def subscribe_percent(fader, index = 0, rate = 0)   # rate must be 0 for non meter controls
+        index_data = id_to_array(index, :gain)
+
         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)
+        do_send([OPERATION_CODE[:subscribe_percent]] + NODE + VIRTUAL + fader + index_data + rate)
     end
 
-    def unsubscribe_percent(fader, control = CONTROLS[:gain])   # rate must be 0 for non meter controls
+    def unsubscribe_percent(fader, index = 0)   # rate must be 0 for non meter controls
+        index_data = id_to_array(index, :gain)
+
         fader = number_to_object(fader.to_i)
         rate = number_to_data(0)
 
-        do_send([OPERATION_CODE[:unsubscribe_percent]] + NODE + VIRTUAL + fader + control + rate)
+        do_send([OPERATION_CODE[:unsubscribe_percent]] + NODE + VIRTUAL + fader + index_data + rate)
     end
 
     #
     # State controls are for discrete values
     #
-    def subscribe_state(fader, rate = 0, control = CONTROLS[:mute]) # 1000 == every second
+    def subscribe_state(fader, index = 1, rate = 0) # 1000 == every second
+        index_data = id_to_array(index, :mute)
+
         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)
+        do_send([OPERATION_CODE[:subscribe_state]] + NODE + VIRTUAL + fader + index_data + rate)
     end
 
-    def unsubscribe_state(fader, control = CONTROLS[:mute]) # 1000 == every second
+    def unsubscribe_state(fader, index = 1) # 1000 == every second
+        index_data = id_to_array(index, :mute)
+
         fader = number_to_object(fader.to_i)
         rate = number_to_data(0)
 
-        do_send([OPERATION_CODE[:unsubscribe_state]] + NODE + VIRTUAL + fader + control + rate)
+        do_send([OPERATION_CODE[:unsubscribe_state]] + NODE + VIRTUAL + fader + index_data + rate)
     end
 
 
@@ -170,10 +186,11 @@ class Bss::Blu100
             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
+                index = byte_to_hex(array_to_str(cntrl)).to_i(16)
+                if @type_lookup[cntrl] == :mute
+                    self[:"fader#{obj}_#{index}_mute"] = data == 1
                 else
-                    self[:"fader_#{obj}"] = data
+                    self[:"fader#{obj}_#{index}"] = data
                 end
             when :subscribe_state
             when :unsubscribe_state
@@ -181,7 +198,8 @@ class Bss::Blu100
             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
+                index = byte_to_hex(array_to_str(cntrl)).to_i(16)
+                self[:"fader#{obj}_#{index}"] = data
             when :subscribe_percent
             when :unsubscribe_percent
             when :set_relative_percent
@@ -198,12 +216,18 @@ class Bss::Blu100
     protected
 
 
+    def id_to_array(id, type)
+        data = str_to_array(hex_to_byte(id.to_s(16).rjust(4, '0')))
+        @type_lookup[data] = type
+        data
+    end
+
     def number_to_data(num)
-        str_to_array(hex_to_byte(num.to_s(16).upcase.rjust(8, '0')))
+        str_to_array(hex_to_byte(num.to_s(16).rjust(8, '0')))
     end
 
     def number_to_object(num)
-        str_to_array(hex_to_byte(num.to_s(16).upcase.rjust(6, '0')))
+        str_to_array(hex_to_byte(num.to_s(16).rjust(6, '0')))
     end
 
 
@@ -211,12 +235,6 @@ class Bss::Blu100
     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)
         #

data/modules/chiyu/cyt.rb

@@ -0,0 +1,183 @@
+module Chiyu; end
+
+
+# Normal state for inputs == open
+# IO Operations mode TCP server
+# Periodically every second
+
+
+# Default port: 50001
+class Chiyu::Cyt
+    include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+
+
+    def on_load
+        @outputs = Array.new(32, 1)
+
+        config({
+            tokenize: true,
+            delimiter: "\xF0\xF0",
+            min_length: 2, # this will ignore the CRC check byte
+            encoding: "ASCII-8BIT"
+        })
+
+        defaults({
+            delay_on_receive: 500
+        })
+    end
+    
+    def on_update
+    end
+    
+    # No keep alive required as the device polls us
+    def connected
+        do_send(:state)
+        do_send(:auto_report)
+    end
+    
+    def disconnected
+    end
+
+
+
+    COMMANDS = {
+        state: [0x00, 0x01],
+        trigger: [0x00, 0x03],
+        auto_report: [0x00, 0x05],
+        ack_keepalive: [0x00, 0x08]
+    }
+
+    RESPONSES = {
+        [0x00, 0x02] => :state,
+        [0x00, 0x04] => :trigger,
+        [0x00, 0x06] => :emailed,
+        [0x00, 0x10] => :report,
+        [0x00, 0x07] => :keepalive,
+        [0x00, 0x08] => :keepalive
+    }
+
+    ERRORS = {
+        0xFC => 'Flag error, incorrect Start Flag or End Flag'.freeze,
+        0xFD => 'Length error, the length of command packet is invalid'.freeze,
+        0xFE => 'CRC error, incorrect CRC value'.freeze,
+        0xFF => 'Command error, no such command'.freeze
+    }
+    
+    
+    
+    def relay(index, state, time = nil)
+        index = index - 1
+        return if index >= 30 || index < 0
+
+        @outputs[index] = is_affirmative?(state) ? 0 : 1
+        opts = {
+            data1: @outputs
+        }
+
+        if time
+            time = time.to_i
+            times = Array.new(32, 0)
+            times[index] = time
+            opts[:data2] = times
+            opts[:delay_on_receive] = time * 1000 + 1200
+        end
+
+        do_send(:trigger, opts)
+        self[:"relay#{index + 1}"] = true
+    end
+    
+    
+    
+    def received(data_str, resolve, command)
+        data = str_to_array(data_str)
+        logger.debug "Chiyu sent #{data}"
+
+        cmd = data[0..1]
+        data1 = data[2..33]
+        data2 = data[34..65]
+
+        if cmd[0] != 0xFF
+            case RESPONSES[cmd]
+            when :state, :report
+                data1.each_index do |index|
+                    next if index >= 30
+                    byte = data1[index]
+                    if byte < 2
+                        self[:"sensor#{index + 1}"] = byte == 1
+                    end
+                end
+
+                @outputs = data2
+                data2.each_index do |index|
+                    next if index >= 30
+                    byte = data2[index]
+                    if byte < 2
+                        self[:"relay#{index + 1}"] = byte == 0
+                    end
+                end
+            when :keepalive
+                do_send(:ack_keepalive)
+            end
+            
+            :success
+        else
+            # Error
+            error = ERRORS[cmd[1]]
+            self[:last_error] = error
+            logger.debug "Chiyu error #{error}"
+            :abort
+        end
+    end
+
+
+
+    # Pulse Lifter Logic
+    #
+    # 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
+    #
+    [:up, :down, :left, :right].each do |helper|
+        define_method helper do |*args|
+            index = args[0] || setting(helper) || 1
+            index = index.to_i
+
+            relay(index, true, 2)
+            relay(index, true, 2)
+        end
+    end
+
+    
+    
+    protected
+
+
+    def checksum!(command)
+        check = 0
+        command.each do |byte|
+            check = check + byte
+        end
+        check = (0 - check) & 0xFF
+        command << check
+    end
+
+
+    FLAG = [0xF0, 0xF0]
+    EMPTY = Array.new(32, 0)
+    
+    
+    def do_send(command, options = {})
+        cmd = FLAG + COMMANDS[command]
+        cmd += options.delete(:data1) || EMPTY
+        cmd += options.delete(:data2) || EMPTY
+        cmd += FLAG
+        checksum!(cmd)
+
+        options[:name] = command unless options[:name]
+
+        send(cmd, options)
+        logger.debug "-- CYT, sending: #{command}"
+    end
+end
+