rfbeam 0.5.0 → 0.5.8

data/lib/rfbeam/kld7/constants.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+# rubocop:disable all
 
 module RfBeam
-  module Kld7
+  module KLD7
     # All supported Serial port baude rates
     BAUDE_RATES = { 0 => 115_200, 1 => 460_800, 2 => 921_600, 3 => 2_000_000, 4 => 3_000_000 }.freeze
 
@@ -25,239 +26,166 @@ module RfBeam
 
     # The angle, direction, range and speed flags are only valid if the detection flag is 1.
     DETECTION_FLAGS = {
-      detection: %w[No Yes],
-      micro_detection: %w[No Yes],
+      detection: ['No Detection', 'Detection'],
+      micro_detection: ['No Detection', 'Detection'],
       angle: %w[Left Right],
-      direction: ['Going away', 'Approaching'],
+      direction: %w[Receding Approaching],
       range: %w[Far Near],
       speed: %w[Low High]
     }.freeze
 
-    class Param
-      attr_accessor :name, :grps_index, :description, :default, :units, :str_values
-
-      def initialize(name:, grps_index:, options: {})
-        @name = name
-        @grps_index = grps_index
-        @description = options.fetch(:description, nil)
-        @default = options.fetch(:default, nil)
-        @units = options.fetch(:units, nil)
-        @str_values = options.fetch(:str_values, [])
+    Param =
+      Data.define(:name, :grps_index, :description, :default, :units, :values) do |_param|
+        def initialize(name:, grps_index:, description: nil, default: nil, units: nil, values: [])
+          super(name:, grps_index:, description:, default:, units:, values:)
+        end
       end
-    end
 
     RADAR_PARAMETERS = {
-      sw_version: Param.new(name: 'Software Version', grps_index: 2, options: { default: 'K-LD7_APP-RFB-XXXX' }),
+      sw_version: Param.new(name: 'Software Version', grps_index: 2, default: 'K-LD7_APP-RFB-XXXX'),
       base_frequency:
         Param.new(
           name: 'Base Frequency',
           grps_index: 3,
-          options: {
-            description: '0 = Low, 1 = Middle, 2 = High',
-            default: 1,
-            str_values: %w[Low Middle High]
-          }
+          description: '0 = Low, 1 = Middle, 2 = High',
+          default: 1,
+          values: %w[Low Middle High]
         ),
       max_speed:
         Param.new(
           name: 'Maximum Speed',
           grps_index: 4,
-          options: {
-            description: '0 = 12km/h, 1 = 25km/h, 2 = 50km/h, 3 = 100km/h',
-            default: 1,
-            units: 'km/h',
-            str_values: %w[12.5 25 50 100]
-          }
+          description: '0 = 12km/h, 1 = 25km/h, 2 = 50km/h, 3 = 100km/h',
+          default: 1,
+          units: 'km/h',
+          values: %w[12.5 25 50 100]
         ),
       max_range:
         Param.new(
           name: 'Maximum Range',
           grps_index: 5,
-          options: {
-            description: '0 = 5m, 1 = 10m, 2 = 30m, 3 = 100m',
-            default: 1,
-            str_values: %w[5m 10m 30m 100m]
-          }
+          description: '0 = 5m, 1 = 10m, 2 = 30m, 3 = 100m',
+          default: 1,
+          values: %w[5m 10m 30m 100m]
         ),
       threshold_offset:
-        Param.new(
-          name: 'Threshold Offset',
-          grps_index: 6,
-          options: {
-            description: '10db - 60db',
-            default: 30,
-            units: 'db'
-          }
-        ),
+        Param.new(name: 'Threshold Offset', grps_index: 6, description: '10db - 60db', default: 30, units: 'db'),
       tracking_filter:
         Param.new(
           name: 'Tracking Filter Type',
           grps_index: 7,
-          options: {
-            description: '0 = Standard, 2 = Fast Detection, 3 = Long Visibility',
-            default: 0,
-            str_values: ['standard', 'Fast Detection', 'Long Visibility']
-          }
+          description: '0 = Standard, 2 = Fast Detection, 3 = Long Visibility',
+          default: 0,
+          values: ['standard', 'Fast Detection', 'Long Visibility']
         ),
       vibration_suppression:
         Param.new(
           name: 'Vibration Suppression',
           grps_index: 8,
-          options: {
-            description: '0-16, 0 = No Suppression, 16 = High Suppression',
-            default: 2
-          }
+          description: '0-16, 0 = No Suppression, 16 = High Suppression',
+          default: 2
         ),
       min_detection_distance:
         Param.new(
           name: 'Minimum Detection Distance',
           grps_index: 9,
-          options: {
-            description: '0 - 100% of range setting',
-            default: 0,
-            units: '%'
-          }
+          description: '0 - 100% of range setting',
+          default: 0,
+          units: '%'
         ),
       max_detection_distance:
         Param.new(
           name: 'Maximum Detection Distance',
           grps_index: 10,
-          options: {
-            description: '0 - 100% of range setting',
-            default: 50,
-            units: '%'
-          }
+          description: '0 - 100% of range setting',
+          default: 50,
+          units: '%'
         ),
       min_detection_angle:
-        Param.new(
-          name: 'Minimum Detection Angle',
-          grps_index: 11,
-          options: {
-            description: '-90° - 90°',
-            default: -90,
-            units: '°'
-          }
-        ),
+        Param.new(name: 'Minimum Detection Angle', grps_index: 11, description: '-90° - 90°', default: -90, units: '°'),
       max_detection_angle:
-        Param.new(
-          name: 'Maximum Detection Angle',
-          grps_index: 12,
-          options: {
-            description: '-90° - 90°',
-            default: 90,
-            units: '°'
-          }
-        ),
+        Param.new(name: 'Maximum Detection Angle', grps_index: 12, description: '-90° - 90°', default: 90, units: '°'),
       min_detection_speed:
         Param.new(
           name: 'Minimum Detection Speed',
           grps_index: 13,
-          options: {
-            description: '0 - 100% of speed setting',
-            default: 0,
-            units: '%'
-          }
+          description: '0 - 100% of speed setting',
+          default: 0,
+          units: '%'
         ),
       max_detection_speed:
         Param.new(
           name: 'Maximum Detection Speed',
           grps_index: 14,
-          options: {
-            description: '0 - 100% of speed setting',
-            default: 100,
-            units: '%'
-          }
+          description: '0 - 100% of speed setting',
+          default: 100,
+          units: '%'
         ),
       detection_direction:
         Param.new(
           name: 'Detection Direction',
           grps_index: 15,
-          options: {
-            description: '0 = Receding, 1 = Approaching, 2 = Both',
-            default: 2,
-            str_values: %w[Receding Approaching Both]
-          }
+          description: '0 = Receding, 1 = Approaching, 2 = Both',
+          default: 2,
+          values: %w[Receding Approaching Both]
         ),
       range_threshold:
         Param.new(
           name: 'Range Threshold',
           grps_index: 16,
-          options: {
-            description: '0 - 100% of range setting',
-            default: 10,
-            units: '%'
-          }
+          description: '0 - 100% of range setting',
+          default: 10,
+          units: '%'
         ),
       angle_threshold:
-        Param.new(
-          name: 'Angle Threshold',
-          grps_index: 17,
-          options: {
-            description: '-90° - 90°',
-            default: 0,
-            units: '°'
-          }
-        ),
+        Param.new(name: 'Angle Threshold', grps_index: 17, description: '-90° - 90°', default: 0, units: '°'),
       speed_threshold:
         Param.new(
           name: 'Speed Threshold',
           grps_index: 18,
-          options: {
-            description: '0 - 100% of speed setting',
-            default: 50,
-            units: '%'
-          }
+          description: '0 - 100% of speed setting',
+          default: 50,
+          units: '%'
         ),
       digital_output1:
         Param.new(
           name: 'Digital Output 1',
           grps_index: 19,
-          options: {
-            description: '0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection',
-            default: 0,
-            str_values: %w[Direction Angle Range Speed Micro]
-          }
+          description: '0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection',
+          default: 0,
+          values: %w[Direction Angle Range Speed Micro]
         ),
       digital_output2:
         Param.new(
           name: 'Digital Output 2',
           grps_index: 20,
-          options: {
-            description: '0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection',
-            default: 1,
-            str_values: %w[Direction Angle Range Speed Micro]
-          }
+          description: '0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection',
+          default: 1,
+          values: %w[Direction Angle Range Speed Micro]
         ),
       digital_output3:
         Param.new(
           name: 'Digital Output 3',
           grps_index: 21,
-          options: {
-            description: '0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection',
-            default: 2,
-            str_values: %w[Direction Angle Range Speed Micro]
-          }
+          description: '0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection',
+          default: 2,
+          values: %w[Direction Angle Range Speed Micro]
         ),
-      hold_time:
-        Param.new(name: 'Hold Time', grps_index: 22, options: { description: '1 - 7200s', default: 1, units: 's' }),
+      hold_time: Param.new(name: 'Hold Time', grps_index: 22, description: '1 - 7200s', default: 1, units: 's'),
       micro_detection_retrigger:
         Param.new(
           name: 'Micro Detection Trigger',
           grps_index: 23,
-          options: {
-            description: '0 = Off, 1 = Retrigger',
-            default: 0,
-            str_values: %w[Off Retrigger]
-          }
+          description: '0 = Off, 1 = Retrigger',
+          default: 0,
+          values: %w[Off Retrigger]
         ),
       micro_detection_sensativity:
         Param.new(
           name: 'Micro Detection Sensativity',
           grps_index: 24,
-          options: {
-            description: '0 - 9, 0 = Min, 9 = Max',
-            default: 4
-          }
+          description: '0 - 9, 0 = Min, 9 = Max',
+          default: 4
         )
     }.freeze
   end

data/lib/rfbeam/kld7/detection_params.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module RfBeam
+  module KLD7
+    # -----------------
+    # Minimum Detection distance, 0 - 100% of Range setting, default = 0
+    # -----------------
+    def min_detection_distance
+      query_parameter RADAR_PARAMETERS[:min_detection_distance].grps_index
+    end
+
+    def min_detection_distance=(value = 0)
+      raise ArgumentError, "Invalid arg: '#{value}'" unless (0..100).cover?(value)
+      raise ArgumentError, 'Expected an Integer' unless value.is_a?(Integer)
+
+      set_parameter :mira, value, :uint32
+    end
+    alias mira= min_detection_distance=
+    alias set_min_detection_distance min_detection_distance=
+
+    # -----------------
+    # Maximum Detection distance, 0 - 100% of Range setting, default = 50
+    # -----------------
+    def max_detection_distance
+      query_parameter RADAR_PARAMETERS[:min_detection_distance].grps_index
+    end
+
+    def max_detection_distance=(value = 50)
+      raise ArgumentError, "Invalid arg: '#{value}'" unless (0..100).cover?(value)
+      raise ArgumentError, 'Expected an Integer' unless value.is_a?(Integer)
+
+      set_parameter :mara, value, :uint32
+    end
+    alias mara= max_detection_distance=
+    alias set_max_detection_distance max_detection_distance=
+
+    # -----------------
+    # Minimum Detection Angle, -90° - 90°, default = -90
+    # -----------------
+    def min_detection_angle
+      query_parameter RADAR_PARAMETERS[:min_detection_angle].grps_index
+    end
+
+    def min_detection_angle=(angle = -90)
+      raise ArgumentError, "Invalid arg: '#{angle}'" unless (-90..90).cover?(angle)
+      raise ArgumentError, 'Expected an Integer' unless angle.is_a?(Integer)
+
+      set_parameter :mian, angle, :int32
+    end
+    alias mian= min_detection_angle=
+    alias set_min_detection_angle min_detection_angle=
+
+    # -----------------
+    # Maximum Detection Angle, -90° - 90°, default = 90
+    # -----------------
+    def max_detection_angleq
+      query_parameter RADAR_PARAMETERS[:max_detection_angle].grps_index
+    end
+
+    def max_detection_angle=(angle = 90)
+      raise ArgumentError, "Invalid arg: '#{angle}'" unless (-90..90).cover?(angle)
+      raise ArgumentError, 'Expected an Integer' unless angle.is_a?(Integer)
+
+      set_parameter :maan, angle, :int32
+    end
+    alias maan= max_detection_angle=
+    alias set_max_detection_angle max_detection_angle=
+
+    # -----------------
+    # Minimum Detection Speed, 0 - 100% of Speed setting, default = 0
+    # -----------------
+    def min_detection_speed
+      query_parameter RADAR_PARAMETERS[:min_detection_angle].grps_index
+    end
+
+    def min_detection_speed=(speed = 0)
+      raise ArgumentError, "Invalid arg: '#{speed}'" unless (0..100).cover?(speed)
+      raise ArgumentError, 'Expected an Integer' unless speed.is_a?(Integer)
+
+      set_parameter :misp, speed, :uint32
+    end
+    alias misp= min_detection_speed=
+    alias set_min_detection_speed min_detection_speed=
+
+    # -----------------
+    # Maximum Detection Speed, 0 - 100% of Speed setting, default = 100
+    # -----------------
+    def max_detection_speed
+      query_parameter RADAR_PARAMETERS[:max_detection_speed].grps_index
+    end
+
+    def max_detection_speed=(speed = 100)
+      raise ArgumentError, "Invalid arg: '#{speed}'" unless (0..100).cover?(speed)
+      raise ArgumentError, 'Expected an Integer' unless speed.is_a?(Integer)
+
+      set_parameter :masp, speed, :uint32
+    end
+    alias masp= max_detection_speed=
+    alias set_max_detection_speed max_detection_speed=
+
+    # -----------------
+    # Detection Direction, 0 = Receding, 1 = Approaching, 2 = Both (default)
+    # -----------------
+    def detection_direction
+      query_parameter RADAR_PARAMETERS[:detection_direction].grps_index
+    end
+
+    def detection_direction=(direction = 2)
+      raise ArgumentError, "Invalid arg: '#{direction}'" unless (0..2).cover?(direction)
+      raise ArgumentError, 'Expected an Integer' unless direction.is_a?(Integer)
+
+      set_parameter :dedi, direction, :uint32
+    end
+    alias dedi= detection_direction=
+    alias set_detection_direction detection_direction=
+
+    # -----------------
+    # Micro Detection retrigger, 0 = Off (default), 1 = Retrigger
+    # -----------------
+    def micro_detection_retrigger
+      query_parameter RADAR_PARAMETERS[:set_micro_detection_retrigger].grps_index
+    end
+
+    def micro_detection_retrigger=(value = 0)
+      raise ArgumentError, "Invalid arg: '#{value}'" unless (0..1).cover?(value)
+      raise ArgumentError, 'Expected an Integer' unless value.is_a?(Integer)
+
+      set_parameter :mide, value, :uint32
+    end
+    alias mide= micro_detection_retrigger=
+    alias set_micro_detection_retrigger micro_detection_retrigger=
+
+    # -----------------
+    # Micro Detection sensitivity, 0 - 9, 0 = Min, 9 = Max, default = 4
+    # -----------------
+    def micro_detection_sensitivity
+      query_parameter RADAR_PARAMETERS[:micro_detection_sensitivity].grps_index
+    end
+
+    def micro_detection_sensitivity=(value = 4)
+      raise ArgumentError, "Invalid arg: '#{value}'" unless (0..9).cover?(value)
+      raise ArgumentError, 'Expected an Integer' unless value.is_a?(Integer)
+
+      set_parameter :mids, value, :uint32
+    end
+    alias mids= micro_detection_sensitivity=
+    alias set_micro_detection_sensitivity micro_detection_sensitivity=
+  end
+end

data/lib/rfbeam/kld7/module_params.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Rfbeam
+  module KLD7
+    # -----------------
+    # Software Version, 'K-LD7_APP-RFB-XXXX'
+    # -----------------
+    def sw_version
+      query_parameter RADAR_PARAMETERS[:sw_version].grps_index
+    end
+
+    # -----------------
+    # Digital output 1, 0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection, default = 0
+    # -----------------
+    def digital_output1
+      query_parameter RADAR_PARAMETERS[:digital_output1].grps_index
+    end
+
+    def digital_output1=(value = 0)
+      raise ArgumentError, "Invalid arg: '#{value}'" unless (0..4).cover?(value)
+      raise ArgumentError, 'Expected an Integer' unless value.is_a?(Integer)
+
+      set_parameter :dig1, value, :uint32
+    end
+    alias dig1= digital_output1=
+    alias set_digital_output1 digital_output1=
+
+    # -----------------
+    # Digital output 2, 0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection, default = 1
+    # -----------------
+    def digital_output2
+      query_parameter RADAR_PARAMETERS[:digital_output2].grps_index
+    end
+
+    def digital_output2=(value = 1)
+      raise ArgumentError, "Invalid arg: '#{value}'" unless (0..4).cover?(value)
+      raise ArgumentError, 'Expected an Integer' unless value.is_a?(Integer)
+
+      set_parameter :dig2, value, :uint32
+    end
+    alias dig2= digital_output2=
+    alias set_digital_output2 digital_output2=
+
+    # -----------------
+    # Digital output 3, 0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection, default = 2
+    # -----------------
+    def digital_output3
+      query_parameter RADAR_PARAMETERS[:digital_output3].grps_index
+    end
+
+    def digital_output3=(value = 2)
+      raise ArgumentError, "Invalid arg: '#{value}'" unless (0..4).cover?(value)
+      raise ArgumentError, 'Expected an Integer' unless value.is_a?(Integer)
+
+      set_parameter :dig3, value, :uint32
+    end
+    alias dig3= digital_output3=
+    alias set_digital_output3 digital_output3=
+
+    # -----------------
+    # Hold Time, 1 - 7200s, default = 1
+    # -----------------
+    def hold_time
+      query_parameter RADAR_PARAMETERS[:hold_time].grps_index
+    end
+
+    def hold_time=(time = 1)
+      raise ArgumentError, "Invalid arg: '#{time}'" unless (1..7200).cover?(time)
+      raise ArgumentError, 'Expected an Integer' unless time.is_a?(Integer)
+
+      set_parameter :hold, time, :uint32
+    end
+    alias hold= hold_time=
+    alias set_hold_time hold_time=
+
+    private
+
+    def query_parameter(index)
+      data = grps
+      data[index]
+    end
+
+    def set_parameter(header, value, return_type = :uint32)
+      char =
+        case return_type
+        when :int32
+          'l'
+        else
+          'L'
+        end
+      command = [header.upcase.to_s, 4, value]
+      write command.pack("a4L#{char}")
+      check_response
+    end
+  end
+end