aca-device-modules 1.0.4 → 1.0.5

data/modules/philips/dynalite.rb

@@ -0,0 +1,196 @@
+module Philips; end
+
+
+class Philips::Dynalite
+    include ::Orchestrator::Constants
+    include ::Orchestrator::Transcoder
+    
+
+    def on_load
+        #
+        # Setup constants
+        #
+        defaults({
+            wait: false,
+            delay: 0.4
+        })
+
+        config({
+            tokenize: true,
+            indicator: "\x1C",
+            msg_length: 7      # length - indicator
+        })
+    end
+
+    def connected
+        @polling_timer = schedule.every('1m') do
+            logger.debug "-- Dynalite Maintaining Connection"
+            get_current_preset(1)    # preset for area 1
+        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
+    
+    
+    #
+    # Arguments: preset_number, area_number, fade_time in millisecond
+    #    Trigger for CBUS module compatibility
+    #
+    def trigger(area, number, fade = 1000)
+        # 0,1,2,3 then a,b,c,d for 4,5,6,7
+        self[:"area#{area}"] = number
+        area = area.to_i
+        number = number.to_i
+        fade = (fade / 10).to_i
+
+        number = number - 1
+        bank = number / 8
+        number = number - (bank * 8)
+
+        if number > 3
+            number = number - 4 + 0x0A
+        end
+                                                       #high fade   #join (currently all in group)
+        command = [0x1c, area & 0xFF, fade & 0xFF, number & 0xFF, (fade >> 8) & 0xFF, bank, 0xFF]
+
+        do_send(command)
+    end
+    # Seems to be an undocument trigger command with opcode 65
+    # -- not sure how fade works with it..
+
+    def get_current_preset(area)
+        command = [0x1c, area.to_i & 0xFF, 0, 0x63, 0, 0, 0xFF]
+        do_send(command)
+    end
+
+    def save_preset(area)
+        command = [0x1c, area.to_i & 0xFF, 0, 0x66, 0, 0, 0xFF]
+        do_send(command)
+    end
+
+
+    def light_level(area, level, channel = 0xFF, fade = 1000)
+        cmd = 0x71
+
+        # Command changes based on the length of the fade time
+        if fade <= 25500
+            fade = (fade / 100).to_i
+        elsif fade < 255000
+            cmd = 0x72
+            fade = (fade / 1000).to_i
+        else
+            cmd = 0x73
+            fade = in_range((fade / 60000).to_i, 22, 1)
+        end
+
+        # Levels
+        #0x01 == 100%
+        #0xFF == 0%
+        level = 0xFF - level.to_i          # Inverse
+        level = in_range(level, 0xFF, 1)
+
+        command = [0x1c, area & 0xFF, channel & 0xFF, cmd, level, fade & 0xFF, 0xFF]
+        do_send(command)
+    end
+
+    def stop_fading(area, channel = 0xFF)
+        command = [0x1c, area.to_i & 0xFF, channel.to_i & 0xFF, 0x76, 0, 0, 0xFF]
+        do_send(command)
+    end
+
+    def stop_all_fading(area)
+        command = [0x1c, area.to_i & 0xFF, 0, 0x7A, 0, 0, 0xFF]
+        do_send(command)
+    end
+
+
+    def get_light_level(area, channel = 0xFF)
+                       # area,            channel,            cmd,        join
+        do_send([0x1c, area.to_i & 0xFF, channel.to_i & 0xFF, 0x61, 0, 0, 0xFF])
+    end
+
+
+    def increment_area_level(area)
+        do_send([0x1c, area.to_i & 0xFF, 0x64, 6, 0, 0, 0xFF])
+    end
+
+
+    def decrement_area_level(area)
+        do_send([0x1c, area.to_i & 0xFF, 0x64, 5, 0, 0, 0xFF])
+    end
+    
+    
+    
+    def received(data, resolve, command)
+        logger.debug "from dynalite 0x#{byte_to_hex(data)}--"
+        
+        data = str_to_array(data)
+
+        case data[2]
+        # current preset selected response
+        when 0, 1, 2, 3, 10, 11, 12, 13
+
+            # 0-3, A-D == preset 1..8
+            number = data[2]
+            number -= 0x0A + 4 if number > 3
+
+            # Data 4 represets the preset offset or bank
+            number += data[4] * 8 + 1
+            self[:"area#{data[0]}"] = number
+
+        # alternative preset response
+        when 0x62
+            self[:"area#{data[0]}"] = data[1] + 1
+
+        # level response (area or channel)
+        when 0x60
+            level = data[3]
+            level = 0 if level <= 1
+            level = 0xFF - level  # Inverse
+
+            if data[1] == 0xFF # Area (all channels)
+                self[:"area#{data[0]}_level"] = level
+            else
+                self[:"area#{data[0]}_chan#{data[1]}_level"] = level
+            end
+        end
+
+        :success
+    end
+    
+    
+    protected
+    
+    
+    def do_send(command, options = {})
+        #
+        # build checksum
+        #
+        check = 0
+        command.each do |byte|
+            check = check + byte
+        end
+        check -= 1
+        check = ~check
+        check = "%x" % check
+        check = check[-2, 2]
+        check = check.to_i(16)
+
+        #
+        # Add checksum to command
+        command << check
+        command = array_to_str(command)
+        
+        send(command, options)
+
+        logger.debug "to dynalite: 0x#{byte_to_hex(command)}--"
+    end
+end
+

data/modules/samsung/displays/md_series.rb

@@ -8,7 +8,7 @@ class Samsung::Displays::MdSeries
 
     #
     # Control system events
-	def on_load
+    def on_load
         on_update
         
         self[:volume_min] = 0
@@ -19,7 +19,7 @@ class Samsung::Displays::MdSeries
             tokenize: proc {
                 ::UV::AbstractTokenizer.new({
                     indicator: "\xAA",
-                    callback: method(:check_checksum)
+                    callback: method(:check_length)
                 })
             }
         })
@@ -27,14 +27,14 @@ class Samsung::Displays::MdSeries
         # Meta data for inquiring interfaces
         self[:type] = :lcd
         self[:input_stable] = true
-	end
-	
-	def on_unload
-	end
-	
-	def on_update
+    end
+    
+    def on_unload
+    end
+    
+    def on_update
         @id = setting(:display_id) || 0xFF
-	end
+    end
 
 
     #
@@ -143,15 +143,19 @@ class Samsung::Displays::MdSeries
 
     #
     # Emulate mute
-    def mute
-        if not self[:audio_mute]
-            self[:audio_mute] = true
-            self[:previous_volume] = self[:volume] || 50
-            volume 0
+    def mute_audio(val = true)
+        if is_affirmative? val
+            if not self[:audio_mute]
+                self[:audio_mute] = true
+                self[:previous_volume] = self[:volume] || 50
+                volume 0
+            end
+        else
+            unmute_audio
         end
     end
 
-    def unmute
+    def unmute_audio
         if self[:audio_mute]
             self[:audio_mute] = false
             volume self[:previous_volume]
@@ -220,7 +224,7 @@ class Samsung::Displays::MdSeries
         end
     end
 
-    # Called by the Abstract Tokenizer
+    # Currently not used. We could check it if we like :)
     def check_checksum(byte_str)
         response = str_to_array(byte_str)
         check = 0
@@ -230,6 +234,20 @@ class Samsung::Displays::MdSeries
         response[-1] == check
     end
 
+    # Called by the Abstract Tokenizer
+    def check_length(byte_str)
+        response = str_to_array(byte_str)
+        return false if response.length <= 3
+
+        len = response[2] + 4 # (data length + header and checksum)
+
+        if response.length >= len
+            return len
+        else
+            return false
+        end
+    end
+
     # Called by do_send to create a checksum
     def checksum(command)
         check = 0

data/modules/screen_technics/connect.rb

@@ -2,72 +2,72 @@ module ScreenTechnics; end
 
 
 class ScreenTechnics::Connect
-	include ::Orchestrator::Constants
+    include ::Orchestrator::Constants
 
 
-	def on_load
-		defaults({
+    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
+        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 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 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
+    def stop(index = 1)
+        do_send({
+            body: "Stop#{index}=Stop",
+            name: :"stop#{index}",
+            priority: 99
+        })
+    end
 
 
-	protected
+    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
+    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/id_talk.rb

@@ -6,11 +6,11 @@ module Sony::Display; end
 # Port: 53484
 #
 class Sony::Display::IdTalk
-	include ::Orchestrator::Constants
+    include ::Orchestrator::Constants
     include ::Orchestrator::Transcoder
 
-	def on_load
-		self[:brightness_min] = 0x00
+    def on_load
+        self[:brightness_min] = 0x00
         self[:brightness_max] = 0x64
         self[:contrast_min] = 0x00
         self[:contrast_max] = 0x64
@@ -29,298 +29,298 @@ class Sony::Display::IdTalk
             }
         })
 
-		on_update
-	end
+        on_update
+    end
 
-	def on_update
-		# Default community value is SONY - can be changed in displays settings
-		@community = str_to_array(setting(:community) || 'SONY')
-	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 connected
+        @polling_timer = schedule.every('60s', method(:do_poll))
+    end
 
-	def disconnected
-		@polling_timer.cancel unless @polling_timer.nil?
+    def disconnected
+        @polling_timer.cancel unless @polling_timer.nil?
         @polling_timer = nil
-	end
-	
-	
-	
-	#
-	# Power commands
-	#
-	def power(state, opt = nil)
-		if is_affirmative?(state)
-			do_send(:power, 1)
-			logger.debug "-- sony display requested to power on"
-		else
-			do_send(:power, 0)
-			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(:power, options)
-	end
-	
-	
-	
-	#
-	# Input selection
-	#
-	INPUTS = {
-		:vga => 0x08,
-		:dvi => 0x20,
-		:hdmi => 0x44,
-		:hdmi2 => 0x84,
-		:hdmi3 => 0x85
-	}
-	INPUTS.merge!(INPUTS.invert)
-	
-	
-	def switch_to(input)
-		input = input.to_sym
-		return unless INPUTS.has_key? input
-		
-		do_send(:input, INPUTS[input])
-		logger.debug "-- sony display, requested to switch to: #{input}"
-		
-		input?
-	end
-
-	def input?
-		do_send(:input, {:priority => 0})
-	end
-	
-	
-	#
-	# Mute Audio and Video
-	#
-	def mute
-		logger.debug "-- sony display, requested to mute"
-		do_send(:mute, 1)
-		mute?
-	end
-
-	def unmute
-		logger.debug "-- sony display, requested to unmute"
-		do_send(:mute, 0)
-		mute?
-	end
-
-	def mute?
-		do_send(:mute, {:priority => 0})
-	end
-
-	def audio_mute
-		logger.debug "-- sony display, requested to mute"
-		do_send(:audio_mute, 1)
-		audio_mute?
-	end
-
-	def audio_unmute
-		logger.debug "-- sony display, requested to unmute"
-		do_send(:audio_mute, 0)
-		audio_mute?
-	end
-
-	def audio_mute?
-		do_send(:audio_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, :volume].each do |command|
-		# Query command
-		define_method :"#{command}?" do
-			do_send(command, {:priority => 0})
-		end
-
-		# Set value command
-		define_method command do |level|
-			do_send(command, level)
-			__send__(:"#{command}?")
-		end
-	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
-	}
-
-	RESP = {
-		0x00 => :success,
-		0x01 => :limit_over,
-		0x02 => :limit_under,
-		0x03 => :cancelled
-	}
-	
-
-	def received(byte_str, resolve, command)		# Data is default received as a string
-		logger.debug "sony display sent: 0x#{byte_to_hex(data)}"
-
-		data = str_to_array(byte_str)
-		idt_command = data[5..6]
-		resp = data[8..-1]
-
-		if data[4] == 0x01
-			# resp is now equal to the unit control codes
-
-			type = RESP[resp[1]]
-
-			case type
-			when :success
-				if resp.length > 3 && command
-					# This is a request response
-					cmd = command[:name]
-
-					case cmd
-					when :power, :audio_mute, :mute
-						self[cmd] = resp[3] == 0x01
-					when :input
-						self[cmd] = INPUTS[resp[3]]
-					when :signal_status
-						self[cmd] = resp[3] != 0x01
-					when :contrast, :brightness, :volume
-						self[cmd] = resp[3]
-					end
-				end
-				return :success
-			when :limit_over, :limit_under
-				warning = "sony display sent a value that was #{type}"
-				warning += " for command #{command[:name]}" if command
-
-				logger.warn warning 
-
-				return :abort
-			when :cancelled
-				# Attempt the request again
-				return :retry
-			end
-
-		else
-			# Command failed.. value == error code
-			return :abort
-		end
-	end
-
-	
-	
-	protected
-
-
-	# Called by the Abstract Tokenizer to confirm we have the
-	# whole message.
+    end
+    
+    
+    
+    #
+    # Power commands
+    #
+    def power(state, opt = nil)
+        if is_affirmative?(state)
+            do_send(:power, 1)
+            logger.debug "-- sony display requested to power on"
+        else
+            do_send(:power, 0)
+            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(:power, options)
+    end
+    
+    
+    
+    #
+    # Input selection
+    #
+    INPUTS = {
+        :vga => 0x08,
+        :dvi => 0x20,
+        :hdmi => 0x44,
+        :hdmi2 => 0x84,
+        :hdmi3 => 0x85
+    }
+    INPUTS.merge!(INPUTS.invert)
+    
+    
+    def switch_to(input)
+        input = input.to_sym
+        return unless INPUTS.has_key? input
+        
+        do_send(:input, INPUTS[input])
+        logger.debug "-- sony display, requested to switch to: #{input}"
+        
+        input?
+    end
+
+    def input?
+        do_send(:input, {:priority => 0})
+    end
+    
+    
+    #
+    # Mute Audio and Video
+    #
+    def mute
+        logger.debug "-- sony display, requested to mute"
+        do_send(:mute, 1)
+        mute?
+    end
+
+    def unmute
+        logger.debug "-- sony display, requested to unmute"
+        do_send(:mute, 0)
+        mute?
+    end
+
+    def mute?
+        do_send(:mute, {:priority => 0})
+    end
+
+    def mute_audio
+        logger.debug "-- sony display, requested to mute audio"
+        do_send(:audio_mute, 1)
+        audio_mute?
+    end
+
+    def unmute_audio
+        logger.debug "-- sony display, requested to unmute audio"
+        do_send(:audio_mute, 0)
+        audio_mute?
+    end
+
+    def audio_mute?
+        do_send(:audio_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, :volume].each do |command|
+        # Query command
+        define_method :"#{command}?" do
+            do_send(command, {:priority => 0})
+        end
+
+        # Set value command
+        define_method command do |level|
+            do_send(command, level)
+            __send__(:"#{command}?")
+        end
+    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
+    }
+
+    RESP = {
+        0x00 => :success,
+        0x01 => :limit_over,
+        0x02 => :limit_under,
+        0x03 => :cancelled
+    }
+    
+
+    def received(byte_str, resolve, command)        # Data is default received as a string
+        logger.debug "sony display sent: 0x#{byte_to_hex(data)}"
+
+        data = str_to_array(byte_str)
+        idt_command = data[5..6]
+        resp = data[8..-1]
+
+        if data[4] == 0x01
+            # resp is now equal to the unit control codes
+
+            type = RESP[resp[1]]
+
+            case type
+            when :success
+                if resp.length > 3 && command
+                    # This is a request response
+                    cmd = command[:name]
+
+                    case cmd
+                    when :power, :audio_mute, :mute
+                        self[cmd] = resp[3] == 0x01
+                    when :input
+                        self[cmd] = INPUTS[resp[3]]
+                    when :signal_status
+                        self[cmd] = resp[3] != 0x01
+                    when :contrast, :brightness, :volume
+                        self[cmd] = resp[3]
+                    end
+                end
+                return :success
+            when :limit_over, :limit_under
+                warning = "sony display sent a value that was #{type}"
+                warning += " for command #{command[:name]}" if command
+
+                logger.warn warning 
+
+                return :abort
+            when :cancelled
+                # Attempt the request again
+                return :retry
+            end
+
+        else
+            # Command failed.. value == error code
+            return :abort
+        end
+    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)
+        bytes = str_to_array(byte_str)
 
-    	# Min message length is 8 bytes
+        # 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
+            return true
         elsif data.length > bytes[7]
-        	# Let the tokeniser know we only want the following number of bytes
-        	return 7 + 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?
-				audio_mute?
-				volume?
-				do_send(:signal_status, {:priority => 0})
-			end
-		end
-	end
-
-	# Constants as per manual page 18
-	# version, category
-	IdTalk_Header = [0x02, 0x10]
-
-	# Unit protocol as per manual page 21
-	# Dedicated unit protocol
-	IdTalk_Type = [0xF1, 0x00]
-
-
-			# category, command
-	COMMANDS = {
-		power: [0x00, 0x00],
-		input: [0x00, 0x01],
-		audio_mute: [0x00, 0x03],
-		signal_status: [0x00, 0x75],
-		mute: [0x00, 0x8D],
-
-		contrast: [0x10, 0x00],
-		brightness: [0x10, 0x01],
-		volume: [0x10, 0x30]
-	}
-	COMMANDS.merge!(COMMANDS.invert)
-
-
-	def build_checksum(command)
-		check = 0
+    
+    
+    def do_poll(*args)
+        power?({:priority => 0}) do
+            if self[:power]
+                input?
+                mute?
+                audio_mute?
+                volume?
+                do_send(:signal_status, {:priority => 0})
+            end
+        end
+    end
+
+    # Constants as per manual page 18
+    # version, category
+    IdTalk_Header = [0x02, 0x10]
+
+    # Unit protocol as per manual page 21
+    # Dedicated unit protocol
+    IdTalk_Type = [0xF1, 0x00]
+
+
+            # category, command
+    COMMANDS = {
+        power: [0x00, 0x00],
+        input: [0x00, 0x01],
+        audio_mute: [0x00, 0x03],
+        signal_status: [0x00, 0x75],
+        mute: [0x00, 0x8D],
+
+        contrast: [0x10, 0x00],
+        brightness: [0x10, 0x01],
+        volume: [0x10, 0x30]
+    }
+    COMMANDS.merge!(COMMANDS.invert)
+
+
+    def build_checksum(command)
+        check = 0
         command.each do |byte|
             check = (check + byte) & 0xFF
         end
         [check]
-	end
-
-
-	def do_send(command, param = nil, options = {})
-		# Check for missing params
-		if param.is_a? Hash
-			options = param
-			param = nil
-		end
-
-		# Control + Mode
-		if param.nil?
-			options[:name] = command
-			cmd = [0x83] + COMMANDS[command] + [0xFF, 0xFF]
-		else
-			options[:name] = :"#{command}_cmd"
-			type = [0x8C] + COMMANDS[command]
-			if !param.is_a?(Array)
-				param = [param]
-			end
-			data = [param.length + 1] + param
-			cmd = type + data
-		end
-
-		cmd = cmd + build_checksum(cmd)
-
-		# Build the IDTalk header         # set request every time?
-		idt_cmd = IdTalk_Header + @community + [0x00] + IdTalk_Type + [cmd.length] + cmd
-
-		send(idt_cmd, options)
-	end
+    end
+
+
+    def do_send(command, param = nil, options = {})
+        # Check for missing params
+        if param.is_a? Hash
+            options = param
+            param = nil
+        end
+
+        # Control + Mode
+        if param.nil?
+            options[:name] = command
+            cmd = [0x83] + COMMANDS[command] + [0xFF, 0xFF]
+        else
+            options[:name] = :"#{command}_cmd"
+            type = [0x8C] + COMMANDS[command]
+            if !param.is_a?(Array)
+                param = [param]
+            end
+            data = [param.length + 1] + param
+            cmd = type + data
+        end
+
+        cmd = cmd + build_checksum(cmd)
+
+        # Build the IDTalk header         # set request every time?
+        idt_cmd = IdTalk_Header + @community + [0x00] + IdTalk_Type + [cmd.length] + cmd
+
+        send(idt_cmd, options)
+    end
 end