aca-device-modules 1.0.0

data/modules/samsung/displays/md_series.rb

@@ -0,0 +1,256 @@
+module Samsung; end
+module Samsung::Displays; end
+
+
+class Samsung::Displays::MdSeries
+    include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+
+    #
+    # Control system events
+	def on_load
+        on_update
+        
+        self[:volume_min] = 0
+        self[:volume_max] = 100
+        self[:power] = false
+
+        config({
+            tokenize: proc {
+                ::UV::AbstractTokenizer.new({
+                    indicator: "\xAA",
+                    callback: method(:check_checksum)
+                })
+            }
+        })
+
+        # Meta data for inquiring interfaces
+        self[:type] = :lcd
+        self[:input_stable] = true
+	end
+	
+	def on_unload
+	end
+	
+	def on_update
+        @id = setting(:display_id) || 0xFF
+	end
+
+
+    #
+    # network events
+    def connected
+        do_poll
+
+        @polling_timer = schedule.every('30s') do
+            logger.debug "-- Polling Display"
+            do_poll
+        end
+    end
+
+    def disconnected
+        #
+        # Disconnected may be called without calling connected
+        #   Hence the check if timer is nil here
+        #
+        self[:power] = false  # As we may need to use wake on lan
+        @polling_timer.cancel unless @polling_timer.nil?
+        @polling_timer = nil
+    end
+
+
+    #
+    # Command types
+    COMMAND = {
+        :hard_off => 0x11,      # Completely powers off
+        :power => 0xF9,         # Technically the panel command
+        :volume => 0x12,
+        :input => 0x14,
+        :mode => 0x18,
+        :size => 0x19,
+        :pip => 0x3C,           # picture in picture
+        :auto_adjust => 0x3D,
+        :wall_mode => 0x5C,     # Video wall mode
+        :safety => 0x5D,
+        :wall_on => 0x84,       # Video wall enabled
+        :wall_user => 0x89      # Video wall user control
+    }
+    COMMAND.merge!(COMMAND.invert)
+
+    # As true power off disconnects the server we only want to
+    # power off the panel. This doesn't work in video walls
+    # so if a nominal blank input is
+    def power(power, broadcast = nil)
+        if is_negatory?(power)
+            # Blank the screen before turning off panel
+            #if self[:power]
+            #    blank = setting(:blank)
+            #    unless blank.nil?
+            #        switch_to blank
+            #    end
+            #end
+            do_send(:power, 1)
+        elsif !self[:connected]
+            wake(broadcast)
+        else
+            do_send(:power, 0)
+        end
+    end
+
+    def hard_off
+        do_send(:hard_off, 0)
+    end
+
+    def power?(options = {}, &block)
+        options[:emit] = block unless block.nil?
+        do_send(:power, [], options)
+    end
+
+
+    INPUTS = {
+        :vga => 0x14,       # pc in manual
+        :dvi => 0x18,
+        :dvi_video => 0x1F,
+        :hdmi => 0x21,
+        :hdmi_pc => 0x22,
+        :hdmi2 => 0x23,
+        :hdmi2_pc => 0x24,
+        :hdmi3 => 0x31,
+        :hdmi3_pc => 0x32,
+        :display_port => 0x25,
+        :dtv => 0x40,
+        :media => 0x60,
+        :widi => 0x61,
+        :magic_info => 0x20
+    }
+    INPUTS.merge!(INPUTS.invert)
+
+    def switch_to(input, options = {})
+        input = input.to_sym if input.class == String
+        self[:input_stable] = false
+        self[:input_target] = input
+        do_send(:input, INPUTS[input], options)
+    end
+
+    def volume(vol, options = {})
+        vol = vol.to_i
+        vol = 0 if vol < 0
+        vol = 100 if vol > 100
+
+        do_send(:volume, vol, options)
+    end
+
+
+    #
+    # Emulate mute
+    def mute
+        if not self[:audio_mute]
+            self[:audio_mute] = true
+            self[:previous_volume] = self[:volume] || 50
+            volume 0
+        end
+    end
+
+    def unmute
+        if self[:audio_mute]
+            self[:audio_mute] = false
+            volume self[:previous_volume]
+        end
+    end
+
+
+    #
+    # Maintain connection
+    def do_poll
+        power?({:priority => 0}) do
+            if self[:power] == On
+                do_send(:volume, [], {:priority => 0})
+                do_send(:input, [], {:priority => 0})
+            end
+        end
+    end
+
+
+    protected
+
+
+    def wake(broadcast)
+        mac = setting(:mac_address)
+        if mac
+            # config is the database model representing this device
+            wake_device(mac, broadcast || '<broadcast>')
+        end
+    end
+
+    def received(response, resolve, command)
+        data = str_to_array(response)
+        if data[2] == 3     # Check for correct data length
+            status = data[3]
+            command = data[4]
+            value = data[5]
+
+            if status == 0x41 # 'A'
+                case COMMAND[command]
+                when :power
+                    self[:power] = value == 0
+                when :volume
+                    self[:volume] = value
+                    if self[:audio_mute] && value > 0
+                        self[:audio_mute] = false
+                    end
+                when :input
+                    self[:input] = INPUTS[value]
+                    if not self[:input_stable]
+                        if self[:input_target] == self[:input]
+                            self[:input_stable] = true
+                        else
+                            switch_to(self[:input_target])
+                        end
+                    end
+                end
+
+                return :success
+            else
+                logger.debug "Samsung failed with: #{byte_to_hex(array_to_str(data))}"
+                return :failed  # Failed response
+            end
+        else
+            logger.debug "Samsung aborted with: #{byte_to_hex(array_to_str(data))}"
+            return :abort   # unknown result
+        end
+    end
+
+    # Called by the Abstract Tokenizer
+    def check_checksum(byte_str)
+        response = str_to_array(byte_str)
+        check = 0
+        response[0..-2].each do |byte|
+            check = (check + byte) & 0xFF
+        end
+        response[-1] == check
+    end
+
+    # Called by do_send to create a checksum
+    def checksum(command)
+        check = 0
+        command.each do |byte|
+            check = (check + byte) & 0xFF
+        end
+        command << check
+    end
+
+    def do_send(command, data = [], options = {})
+        data = [data] unless data.is_a?(Array)
+
+        if command.is_a?(Symbol)
+            options[:name] = command if data.length > 0     # name unless status request
+            command = COMMAND[command]
+        end
+
+        data = [command, 0xFF, data.length] + data    # Build request (0xFF is screen id)
+        checksum(data)                                # Add checksum
+        data = [0xAA] + data                          # Add header
+        send(array_to_str(data), options)
+    end
+end
+

data/modules/vaddio/camera/clear_view_ptz_telnet.rb

@@ -0,0 +1,138 @@
+module Vaddio; end
+module Vaddio::Camera; end
+
+
+# TCP Port: 23
+class Vaddio::Camera::ClearViewPtzTelnet
+    include ::Orchestrator::Constants    # these provide optional helper methods
+    include ::Orchestrator::Transcoder   # (not used in this module)
+
+
+    def on_load
+        # Setup tokenisation of connection
+        config({
+            tokenize: true,
+            indicator: "\e[J\r\n",
+            delimiter: "\r\n> \e[J", # VT100 string -ESC[J
+            wait_ready: "login: "
+        })
+
+        # Default send options
+        defaults({
+            delay: 150  # time in ms between commands giving the unit time to process
+        })
+
+
+        # Constants that are made available to interfaces
+        self[:pan_speed_max] = 24
+        self[:pan_speed_min] = 1
+        self[:tilt_speed_max] = 24
+        self[:tilt_speed_min] = 1
+        self[:zoom_speed_max] = 7
+        self[:zoom_speed_min] = 1
+
+        # Restart schedule (prevents it crashing)
+        # Every night at 01:00am restart the camera unless defined otherwise
+        schedule.cron(setting(:restart_time) || '0 1 * * *') do
+            reboot
+        end
+    end
+    
+    def on_unload
+    end
+    
+    def on_update
+    end
+    
+    def connected
+        self[:power] = true
+        @polling_timer = schedule.every('60s') do
+            logger.debug "-- Polling Vaddio Camera"
+            version    # Low priority sent to maintain the connection
+        end
+
+        # Send the login password (wait false as not expecting a response)
+        send "admin\r", wait: false
+        password = setting(:password) ? "#{setting(:password)}\r" : "password\r"
+        send password, wait: false
+    end
+    
+    def disconnected
+        self[:power] = false
+
+        # Disconnected will be called before connect if initial connect fails
+        @polling_timer.cancel unless @polling_timer.nil?
+        @polling_timer = nil
+    end
+
+
+    def power(state)
+        # Here for compatibility with other camera modules
+    end
+
+    def power?(options = nil, &block)
+        block.call unless block.nil?
+    end
+
+
+    # direction: left, right, stop
+    def pan(direction, speed = 16)
+        params = direction.to_sym == :stop ? direction : "#{direction} #{speed}"
+        send "camera pan #{params}\r", name: :pan
+    end
+
+    # direction: up, down, stop
+    def tilt(direction, speed = 16)
+        params = direction.to_sym == :stop ? direction : "#{direction} #{speed}"
+        send "camera tilt #{params}\r", name: :tilt
+    end
+
+    def home
+        send "camera home\r", name: :home
+    end
+
+    # number 1->6 inclusive
+    def preset(number, command = :recall)
+        send "camera #{command} #{number}\r", name: :preset
+    end
+
+    # direction: in, out, stop
+    def zoom(direction, speed = 3)
+        params = direction.to_sym == :stop ? direction : "#{direction} #{speed}"
+        send "camera zoom #{params}\r", name: :zoom
+    end
+
+    def reboot(from_now = 0)
+        # Not named so it won't be stored in the queue when not connected
+        # -> Named commands persist disconnect and will execute in order on connect
+        send "reboot #{from_now}\r"
+    end
+
+    def version
+        send "version\r", priority: 0, wait: false
+    end
+
+    
+    protected
+
+
+    def received(data, resolve, command)
+        logger.debug "Vaddio sent #{data}"
+
+        # Deals with multi-line responses
+        data = data.split("\r\n")[-1]
+
+        case data.to_sym
+        when :OK
+            :success
+        when :ERROR, :"Syntax error: Unknown or incomplete command"
+            warning = "Vaddio issue: #{data}"
+            warning << " for command #{command[:data]}" if command
+            logger.warn warning
+            :abort
+        else
+            :ignore
+        end
+    end
+end
+

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: aca-device-modules
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Stephen von Takach
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: orchestrator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Building automation and IoT control modules
+email:
+- steve@cotag.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- aca-device-modules.gemspec
+- lib/aca-device-modules.rb
+- lib/aca-device-modules/engine.rb
+- lib/aca-device-modules/version.rb
+- modules/aca/pc_control.rb
+- modules/axis/camera/vapix.rb
+- modules/biamp/nexia.rb
+- modules/bss/blu100.rb
+- modules/clipsal/c_bus.rb
+- modules/epson/projector/esc_vp21.rb
+- modules/extron/mixer/dmp44.rb
+- modules/extron/mixer/dmp64.rb
+- modules/extron/switcher/dxp.rb
+- modules/global_cache/gc100.rb
+- modules/kramer/switcher/vs_hdmi.rb
+- modules/panasonic/camera/he50.rb
+- modules/panasonic/projector/pj_link.rb
+- modules/samsung/displays/md_series.rb
+- modules/vaddio/camera/clear_view_ptz_telnet.rb
+homepage: http://cotag.me/
+licenses:
+- LGPL3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Open Source Control Modules by ACA
+test_files: []
+has_rdoc: