rfbeam 0.3.4 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 698385739f70574b698a117af8c749a21ebd75d9c3b0abaa39447ebd869324ef
-  data.tar.gz: 11f47d264d76f5a5b968c8f7cb49152602359383e8a0cf20a16564a2b2e808f3
+  metadata.gz: 139acc0d00964189f2eadbba6ed9c7b0e3f4b6c5104a757b2c1ab335d0e30c22
+  data.tar.gz: 86370312525afb17e493aa4b561a68b0f57dc48122f3ecd5f389c421c512cbe8
 SHA512:
-  metadata.gz: 58b01ae8497458e6e4f238afcc64a38cd925312e7893b4e65a854407f34694493b002e5721a9980129d586370cc51abfca5e5cd238a51cf33dfb890f40992479
-  data.tar.gz: 48934f301cb4eb9ac2cdb695d08dfd544cc9e6ea16f130ab6b30b182c35ee1630d5ad2574c4bab081656f51ce4208857c92a2dfd6d2925639c303a3c66c0d1ae
+  metadata.gz: 76e49986de83640754506d935a5a46b0c74548fe96ac7fec03bff66efe048937eaf1dd1175ea25658e3cbdc3705f6f4744df56c969f584e9f3763629d37fbe0e
+  data.tar.gz: 0d032f953bca0658fb4edec3544925bd1fe675b759b1a9759a8cfbffea0abd76f7e1690bb9ae87df5d700a102d4c713f5bb858ca7a8b855d039c3ea448e94428

data/.rubocop.yml

@@ -2,10 +2,16 @@ inherit_from:
   - node_modules/@prettier/plugin-ruby/rubocop.yml
 
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.2
 
 Layout/LineLength:
   Max: 120
 
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Max: 15
+
 Documentation:
   Enabled: false

data/CHANGELOG.md

@@ -1,6 +1,11 @@
+## [0.3.5] - 2023-4-1
+
+- Updated Radar parameter accessors
+- Added parameter setter arg validation and errors
+
 ## [0.3.4] - 2023-3-28
 
- - Added a formatted option to pdat
+- Added a formatted option to pdat
 
 ## [0.3.2] - 2023-3-28
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rfbeam (0.3.4)
+    rfbeam (0.3.5)
       activesupport (~> 6.1.0)
       rubyserial (~> 0.6.0)
       thor (~> 1.2.1)

data/README.md

@@ -1,7 +1,11 @@
 # Rfbeam
 
-RfBeam is a simple, high-level interface to the RFBeam radar modules.
-The user can read and set the radar parameters and fetch raw or processed data frames from the sensor.
+![Gem](https://img.shields.io/gem/v/rfbeam?color=green&label=version)
+![Ruby](https://img.shields.io/static/v1?message=Ruby&color=red&logo=Ruby&logoColor=FFFFFF&label=v3.2.1)
+![Ruby](https://img.shields.io/gitlab/license/robcarruthers/rfbeam?color=orange)
+
+RfBeam is a simple, high-level interface for the RFBeam radar modules.
+The user can query process and raw detection data and set the radar parameters for the sensor.
 
 At this stage it only works on Linux and Mac with the K-LD7 module.
 
@@ -63,28 +67,29 @@ Returns a formatted String of all parameter settings. The only way to read param
 
     radar.config
 
-    Software Version: K-LD7_APP-RFB-0103
-    Base Frequency: Middle
-    Max Speed: 25km/h
-    Max Range: 10m
-    Threshold offset: 30db
-    Tracking Filter Type: standard
-    Vibration Suppression: 2 , (0-16, 0 = No Suppression, 16 = High Suppression)
-    Minimum Detection Distance: 0 , (0 - 100% of range setting)
-    Maximum Detection Distance: 50 , (0 - 100% of range setting)
-    Minimum Detection Angle: -90° , (-90° - 90°)
-    Maximum Detection Angle: 90° , (0 - 100% of range setting)
-    Maximum Detection Speed: 0 , (0 - 100% of speed setting)
-    Maximum Detection Speed: 100 , (0 - 100% of speed setting)
-    Detection Direction: 2Range Threshold: 10%, (0 - 100% of range setting)
-    Angle Threshold: 0°, (-90° - 90°)
-    Speed Threshold: 50%, (0 - 100% of speed setting)
-    Digital output 1: Direction
-    Digital output 2: Angle
-    Digital output 3: Range
-    Hold time: 1sec
-    Micro Detection Retrigger: Off
-    Micro Detection Sensitivity: 4 (0 - 9, 0 = Min, 9 = Max)
+    Software Version: K-LD7_APP-RFB-0103          
+    Base Frequency: Low                           
+    Maximum Speed: 100km/h                        
+    Maximum Range: 100m                           
+    Threshold Offset: 30db                        
+    Tracking Filter Type: Long Visibility         
+    Vibration Suppression: 16
+    Minimum Detection Distance: 0%
+    Maximum Detection Distance: 100%
+    Minimum Detection Angle: -10°
+    Maximum Detection Angle: 90°
+    Minimum Detection Speed: 0%
+    Maximum Detection Speed: 100%
+    Detection Direction: Both
+    Range Threshold: 10%
+    Angle Threshold: 0°
+    Speed Threshold: 50%
+    Digital Output 1: Direction
+    Digital Output 2: Angle
+    Digital Output 3: Range
+    Hold Time: 1s
+    Micro Detection Trigger: Off
+    Micro Detection Sensativity: 4
 
 ## Parameter setters
 

data/lib/rfbeam/kld7/constants.rb

@@ -11,7 +11,7 @@ module RfBeam
       3 => 'Invalid RPST version',
       4 => 'Uart error (parity, framing, noise)',
       5 => 'Sensor busy',
-      6 => 'Timeout error',
+      6 => 'Timeout error'
     }.freeze
 
     # The response delay was determined empirically and may need adjusting with baude rate
@@ -27,59 +27,39 @@ module RfBeam
       angle: %w[Left Right],
       direction: %w[Receding Approaching],
       range: %w[Far Near],
-      speed: %w[Low High],
-  }.freeze
+      speed: %w[Low High]
+    }.freeze
     
-    # GRPS - Parameter structure, used to map return values to readable strings
-    PARAMETER_STRUCTURE = {
-      base_frequency: ['Low', 'Middle', 'High'],
-      max_speed: ['12.5km/h', '25km/h', '50km/h', '100km/h'],
-      max_range: %w[5m 10m 30m 100m],
-      threshold_offset: '10db - 60db',
-      tracking_filter_type: ['standard', 'Fast Detection', 'Long Visibility'],
-      vibration_suppression: '0-16, 0 = No Suppression, 16 = High Suppression',
-      min_detection_distance: '0 - 100% of range setting',      
-      max_detection_distance: '0 - 100% of range setting',
-      min_detection_angle: '-90° - 90°',
-      max_detection_angle: '-90° - 90°',
-      min_detection_speed: '0 - 100% of speed setting',
-      max_detection_speed: '0 - 100% of speed setting',
-      detection_direction: %w[receding approaching both],
-      range_threshold: '0 - 100% of range setting',
-      angle_threshold: '-90° - 90°',
-      speed_threshold: '0 - 100% of speed setting',
-      digital_output_1: %w[Direction Angle Range Speed Micro],
-      digital_output_2: %w[Direction Angle Range Speed Micro],
-      digital_output_3: %w[Direction Angle Range Speed Micro],
-      hold_time: '1 - 7200s',
-      micro_detection_trigger: %w[Off Retrigger],
-      micro_detection_sensitivity: '0 - 9, 0 = Min, 9 = Max'
+    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
+
+    RADAR_PARAMETERS = {
+      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, description: '0 = Low, 1 = Middle, 2 = High', default: 1, values: ['Low', 'Middle', 'High'] ),
+      max_speed: Param.new( name: 'Maximum Speed', grps_index: 4, description: '0 = 12km/h, 1 = 25km/h, 2 = 50km/h, 3 = 100km/h', default: 1, units: 'km/h', values: ['12.5', '25', '50', '100'] ),
+      max_range: Param.new( name: 'Maximum Range', grps_index: 5, description: '0 = 5m, 1 = 10m, 2 = 30m, 3 = 100m', default: 1, values: %w[5m 10m 30m 100m] ),
+      threshhold_offset: 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, 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, description: '0-16, 0 = No Suppression, 16 = High Suppression', default: 2 ),
+      min_detection_distance: Param.new( name: 'Minimum Detection Distance', grps_index: 9, description: '0 - 100% of range setting', default: 0, units: '%' ),
+      max_detection_distance: Param.new( name: 'Maximum Detection Distance', grps_index: 10, description: '0 - 100% of range setting', default: 50, units: '%' ),
+      min_detection_angle: 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, description: '-90° - 90°', default: 90, units: '°' ),
+      min_detection_speed: Param.new( name: 'Minimum Detection Speed', grps_index: 13, description: '0 - 100% of speed setting', default: 0, units: '%' ),
+      max_detection_speed: Param.new( name: 'Maximum Detection Speed', grps_index: 14, description: '0 - 100% of speed setting', default: 100, units: '%' ),
+      detection_direction: Param.new( name: 'Detection Direction', grps_index: 15, description: '0 = Receding, 1 = Approaching, 2 = Both', default: 2, values: %w[Receding Approaching Both] ),
+      range_threshold: Param.new( name: 'Range Threshold', grps_index: 16, description: '0 - 100% of range setting', default: 10, units: '%' ),
+      angle_threshold: Param.new( name: 'Angle Threshold', grps_index: 17, description: '-90° - 90°', default: 0, units: '°' ),
+      speed_threshold: Param.new( name: 'Speed Threshold', grps_index: 18, description: '0 - 100% of speed setting', default: 50, units: '%' ),
+      digital_output1: Param.new( name: 'Digital Output 1', grps_index: 19, 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, 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, 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, description: '1 - 7200s', default: 1, units: 's' ),
+      micro_detection_retrigger: Param.new( name: 'Micro Detection Trigger', grps_index: 23, description: '0 = Off, 1 = Retrigger', default: 0, values: %w[Off Retrigger] ),
+      micro_detection_sensativity: Param.new( name: 'Micro Detection Sensativity', grps_index: 24, description: '0 - 9, 0 = Min, 9 = Max', default: 4 )
   }.freeze
-    
-    # PARAMETERS = {
-    #   sw_version: { grps_index: 2, default: 'K-LD7_APP-RFB-XXXX' },
-    #   base_frequency: { grps_index: 3, description: '0 = Low, 1 = Middle, 2 = High', default: '1 - Middle', values: ['Low', 'Middle', 'High'] },
-    #   max_speed: { grps_index: 4, description: '0 = 12km/h, 1 = 25km/h, 2 = 50km/h, 3 = 100km/h, default: 1', values: ['12.5km/h', '25km/h', '50km/h', '100km/h'] },
-    #   max_range: { grps_index: 5, description: '0 = 5m, 1 = 10m, 2 = 30m, 3 = 100m, default: 1', values: %w[5m 10m 30m 100m] },
-    #   threshold_offset: { grps_index: 6, description: '10db - 60db, default: 30', values: '10db - 60db' },
-    #   tracking_filter_type: { grps_index: 7, description: '0 = Standard, 2 = Fast Detection, 3 = Long Visibility, default: 0', values: ['standard', 'Fast Detection', 'Long Visibility'] },
-    #   vibration_suppression: { grps_index: 8, description: '0-16, 0 = No Suppression, 16 = High Suppression, default: 2' },
-    #   min_detection_distance: { grps_index: 3, description: '0 - 100% of range setting, default: 0' },
-    #   max_detection_distance: { grps_index: 10, description: '0 - 100% of range setting, default: 50' },
-    #   min_detection_angle: { grps_index: 11, description: '-90° - 90°, default: -90' },
-    #   max_detection_angle: { grps_index: 12, description: '-90° - 90°, default: 90' },
-    #   min_detection_speed: { grps_index: 13, description: '0 - 100% of speed setting, default: 0' },
-    #   max_detection_speed: { grps_index: 14, description: '0 - 100% of speed setting, default: 100' },
-    #   detection_direction: { grps_index: 15, description: '0 = Receding, 1 = Approaching, 2 = Both, default: 2', values: %w[receding approaching both] },
-    #   range_threshold: { grps_index: 16, description: '0 - 100% of range setting, default: 10', values: '0 - 100% of range setting' },
-    #   angle_threshold: { grps_index: 17, description: '-90° - 90°, default: 0' },
-    #   speed_threshold: { grps_index: 18, description: '0 - 100% of speed setting, default: 50' },
-    #   digital_output_1: { grps_index: 19, description: '0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection, default: 0', values: %w[Direction Angle Range Speed Micro] },
-    #   digital_output_2: { grps_index: 20, description: '0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection, default: 1', values: %w[Direction Angle Range Speed Micro] },
-    #   digital_output_3: { grps_index: 21, description: '0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection, default: 2', values: %w[Direction Angle Range Speed Micro] },
-    #   hold_time: { grps_index: 22, description: '1 - 7200s, default: 1', values: '1 - 7200s' },
-    #   micro_detection_trigger: { grps_index: 23, description: '0 = Off, 1 = Retrigger, default: 0' },
-    #   micro_detection_sensitivity: { grps_index: 24, description: '0 - 9, 0 = Min, 9 = Max, default: 4' }'
-    # }
   end
 end

data/lib/rfbeam/kld7/radar_messages.rb

@@ -0,0 +1,81 @@
+module RfBeam
+  module KLD7
+    def detection?
+      data = ddat
+      (data[2] == 1)
+    end
+    
+    def pdat(formatted: false)
+      request_frame_data(:pdat)      
+      resp = read(102).unpack('a4LSssSSssSSssSSssSSssSSssSSssSSssSSssSSssS')
+      return resp unless formatted
+
+      target_count = resp[1].to_i / 8
+      return [] unless target_count > 0
+
+      resp.shift 2
+      resp.compact
+      detected_raw_targets = []
+      target_count.times { detected_raw_targets << format_raw_target_data(resp.shift(4)) }
+      detected_raw_targets
+    end
+
+    def tdat
+      request_frame_data(:tdat)
+
+      sleep 0.1
+      resp = read(16).unpack('a4LSssS')
+      return { dist: resp[2], speed: resp[3], angle: resp[4], mag: resp[5] } unless resp[1].zero?
+    end
+
+    def ddat
+      request_frame_data(:ddat)
+
+      read(14).unpack('a4LC6')
+    end
+    
+    def config
+      puts formatted_grps(grps)
+    end
+    
+    def formatted_parameter(param)
+      return unless PARAMETERS.include? param
+      
+      param_data = PARAMETERS[param]
+      grps_data = grps
+      index = grps_data[param_data[:grps_index]]
+      param_data[:values][index]
+    end
+
+    # Get the radar parameter structure
+    def grps
+      command = ['GRPS', 0]
+      write command.pack('a4L')
+      check_response
+      read(50).unpack('a4LA19C8c2C4cCCCCSCC')
+    end
+    
+
+    private
+
+    def format_raw_target_data(array)
+        { dist: array.shift, speed: array.shift, angle: array.shift, mag: array.shift }
+    end
+
+    def request_frame_data(type)
+      command = ['GNFD', 4, FRAME_DATA_TYPES[type]]
+      write command.pack('a4LL')
+      check_response
+    end
+
+    def formatted_grps(data)
+      output = "\n"
+      RADAR_PARAMETERS.each do |param|
+        param = param[1]
+        value = param.values.empty? ? data[param.grps_index] : param.values[data[param.grps_index].to_i]
+        output << "#{param.name}: #{value}#{param.units}\n"
+      end
+      output
+    end
+  end
+end

data/lib/rfbeam/kld7/radar_parameters.rb

@@ -0,0 +1,390 @@
+module RfBeam
+  module KLD7
+
+    # -----------------
+    # Base Frequency, 0 = low, 1 = middle (default), 2 = high
+    # -----------------
+    def base_frequency
+      query_parameter RADAR_PARAMETERS[:base_frequency].grps_index
+    end
+    alias rbfr base_frequency
+    
+    def base_frequency=(frequency = 1)
+      value = case frequency
+        when 0, :low, 'low'
+          0
+        when 1, :middle, 'middle'
+          1
+        when 2, :high, 'high'
+          2
+        else
+          raise ArgumentError, "Invalid arg: '#{frequency}'"
+        end
+      set_parameter(:rbfr, value, :uint32)
+    end
+
+    alias set_base_frequency base_frequency=
+    alias rbfr= base_frequency=
+    
+    # -----------------
+    # Maximum Speed, 0 = 12.5km/h, 1 = 25km/h (default), 2 = 50km/h, 3 = 100km/h
+    # -----------------
+    def max_speed
+      query_parameter(RADAR_PARAMETERS[:max_speed].grps_index)
+    end
+    
+    def max_speed=(speed = 1)
+      raise ArgumentError, "Invalid arg: '#{speed}'" unless (0..3).include?(speed)
+      raise ArgumentError, "Expected an Integer" unless speed.is_a?(Integer)
+      
+      set_parameter :rspi, speed, :uint32
+    end
+    
+    alias set_max_speed max_speed=
+    alias rspi max_speed=
+    
+    # -----------------
+    # Maximum Range, 0 = 5m, 1 = 10m (default), 2 = 30m, 3 = 100m
+    # -----------------
+    def max_range
+      query_parameter(RADAR_PARAMETERS[:max_range].grps_index)
+    end
+    
+    def max_range=(range = 1)
+      raise ArgumentError, "Invalid arg: '#{range}'" unless (0..3).include?(range)
+      
+      set_parameter :rrai, range, :uint32
+    end
+    
+    alias rrai= max_range=
+    alias set_max_range max_range=
+    
+    # -----------------
+    # Threshold Offset, 10 - 60db, (default = 30)
+    # -----------------
+    def threshold_offset
+      query_parameter RADAR_PARAMETERS[:threshold_offset].grps_index
+    end
+    
+    def threshold_offset=(offset = 30)
+      raise ArgumentError, "Invalid arg: '#{offset}'" unless (10..60).include?(offset)
+      raise ArgumentError, "Expected an Integer" unless range.is_a?(Integer)
+      
+      set_parameter :thof, offset, :uint32
+    end
+    
+    alias thof= threshold_offset=
+    alias set_threshold_offset threshold_offset=
+    
+    # -----------------
+    # Tracking filter type, 0 = Standard (Default), 1 = Fast Tracking, 2 = Long visibility
+    # -----------------
+    def tracking_filter
+      query_parameter RADAR_PARAMETERS[:tracking_filter].grps_index
+    end
+    
+    def set_tracking_filter(type = 0)
+      raise ArgumentError, "Invalid arg: '#{type}'" unless (0..2).include?(type)
+      raise ArgumentError, "Expected an Integer" unless type.is_a?(Integer)
+      
+      set_parameter :trft, type, :uint32
+    end
+    alias trtf set_tracking_filter
+    
+    # -----------------
+    # Vibration suppression, 0 - 16, 0 = No Suppression, 16 = High Suppression, default = 2
+    # -----------------
+    def vibration_suppression
+      query_parameter RADAR_PARAMETERS[:vibration_suppression].grps_index
+    end
+    
+    def vibration_suppression=(value = 2)
+      raise ArgumentError, "Invalid arg: '#{value}'" unless (0..16).include?(value)
+      raise ArgumentError, "Expected an Integer" unless value.is_a?(Integer)
+      
+      set_parameter :visu, value, :uint32  
+    end
+    alias visu= vibration_suppression=
+    alias set_vibration_suppression vibration_suppression=
+    
+    # -----------------
+    # 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).include?(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).include?(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).include?(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).include?(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).include?(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).include?(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).include?(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=
+    
+    # -----------------
+    # Range Threshold, 0 - 100% of Range setting, default = 10
+    # -----------------
+    def range_threshold
+      query_parameter RADAR_PARAMETERS[:range_threshold].grps_index
+    end
+    
+    def range_threshold=(value = 10)
+      raise ArgumentError, "Invalid arg: '#{value}'" unless (0..100).include?(value)
+      raise ArgumentError, "Expected an Integer" unless value.is_a?(Integer)
+      
+      set_parameter :rath, value, :uint32
+    end
+    alias rath= range_threshold=
+    alias set_range_threshold range_threshold=
+    
+    # -----------------
+    # Angle Threshold, -90° to 90°, default = 0
+    # -----------------
+    def angle_threshold
+      query_parameter RADAR_PARAMETERS[:angle_threshold].grps_index
+    end
+    
+    def angle_threshold=(value = 0)
+      raise ArgumentError, "Invalid arg: '#{value}'" unless (-90..90).include?(value)
+      raise ArgumentError, "Expected an Integer" unless value.is_a?(Integer)
+      
+      set_parameter :anth, value, :int32
+    end
+    alias anth= angle_threshold=
+    alias set_angle_threshold angle_threshold=
+    
+    # -----------------
+    # Speed Threshold, 0 - 100% of speed setting, default = 50
+    # -----------------
+    def speed_threshold
+      query_parameter RADAR_PARAMETERS[:speed_threshold].grps_index
+    end
+    
+    def speed_threshold=(value = 50)
+      raise ArgumentError, "Invalid arg: '#{value}'" unless (0..100).include?(value)
+      raise ArgumentError, "Expected an Integer" unless value.is_a?(Integer)
+      
+      set_parameter :spth, value, :uint32
+    end
+    alias spth= angle_threshold=
+    alias set_speed_threshold angle_threshold=
+    
+    # -----------------
+    # 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).include?(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).include?(value)
+      raise ArgumentError, "Expected an Integer" unless value.is_a?(Integer)  
+      
+      set_parameter :dig2, value, :uint32
+    end
+    alias dig2= set_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).include?(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).include?(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=
+    
+    # -----------------
+    # 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).include?(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).include?(value)
+      raise ArgumentError, "Expected an Integer" unless value.is_a?(Integer)  
+      
+      set_parameter :mids, value, :uint32
+    end
+    alias mids= micro_detection_sensitivty=
+    alias set_micro_detection_sensitivity micro_detection_sensitivty=
+
+    private
+
+    def query_parameter(index)
+      data = grps
+      data[index]
+    end
+    
+    def set_parameter(header, value, return_type = :uint32)
+      return_type =
+        case return_type
+          when :uint32
+          'L'
+          when :int32
+          'l'
+          when :uint32
+          'S'
+          else
+          'L'
+        end
+      command = [header.upcase.to_s, 4, value]
+      write command.pack("a4L#{return_type}")
+      check_response
+    end
+  end
+end

data/lib/rfbeam/kld7/{connection.rb → serial_connection.rb}

@@ -2,8 +2,6 @@ module RfBeam
   module KLD7
     require 'rubyserial'
     require 'timeout'
-
-
     
     class Error < StandardError
     end

data/lib/rfbeam/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RfBeam
-  VERSION = '0.3.4'
+  VERSION = '0.3.5'
 end

data/lib/rfbeam.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'rfbeam/kld7/app_commands'
-require 'rfbeam/kld7/app_messages'
-require 'rfbeam/kld7/connection'
+require 'rfbeam/kld7/radar_parameters'
+require 'rfbeam/kld7/radar_messages'
+require 'rfbeam/kld7/serial_connection'
 require 'rfbeam/kld7/constants'
 require_relative 'rfbeam/version'
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rfbeam
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Rob Carruthers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-31 00:00:00.000000000 Z
+date: 2023-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -69,10 +69,10 @@ files:
 - README.md
 - Rakefile
 - lib/rfbeam.rb
-- lib/rfbeam/kld7/app_commands.rb
-- lib/rfbeam/kld7/app_messages.rb
-- lib/rfbeam/kld7/connection.rb
 - lib/rfbeam/kld7/constants.rb
+- lib/rfbeam/kld7/radar_messages.rb
+- lib/rfbeam/kld7/radar_parameters.rb
+- lib/rfbeam/kld7/serial_connection.rb
 - lib/rfbeam/version.rb
 - node_modules/.bin/prettier
 - node_modules/.yarn-integrity

data/lib/rfbeam/kld7/app_commands.rb

@@ -1,201 +0,0 @@
-module RfBeam
-  module KLD7
-
-    # Base Frequency, 0 = low, 1 = middle (default), 2 = high
-    def base_frequency
-      data = grps
-      data[3]
-    end
-    alias rbfr base_frequency
-    
-    
-    def set_base_frequency(frequency = 1)
-      value = case frequency
-        when 0, :low, 'low'
-          0
-        when 1, :middle, 'middle'
-          1
-        when 2, :high, 'high'
-          2
-        else
-          raise ArgumentError, "Invalid arg: '#{frequency}'"
-        end
-      set_parameter(:rbfr, value, :uint8)
-    end
-    alias set_rbfr set_base_frequency
-    
-    # Maximum Speed, 0 = 12.5km/h, 1 = 25km/h (default), 2 = 50km/h, 3 = 100km/h
-    def set_max_speed(speed = 1)
-      set_parameter :rspi, speed, :uint8
-    end
-    alias rspi set_max_speed
-    
-    # Maximum Range, 0 = 5m, 1 = 10m (default), 2 = 30m, 3 = 100m
-    def set_max_range(range = 1)
-      set_parameter :rrai, range, :uint8
-    end
-    alias rrai set_max_range
-    
-    # Threshold Offset, 10 - 60db, (default = 30)
-    def set_threshold_offset(offset = 30)
-      range = 10..60
-      return false unless range.include?(offset)
-      
-      set_parameter :thof, offset, :uint8
-    end
-    alias thof set_threshold_offset
-    
-    # Tracking filter type, 0 = Standard (Default), 1 = Fast Tracking, 2 = Long visibility
-    def set_tracking_filter(type = 0)
-        set_parameter :trft, type, :uint8
-    end
-    alias trtf set_tracking_filter
-    
-    # Vibration suppression, 0 - 16, 0 = No Suppression, 16 = High Suppression, default = 2
-    def set_vibration_suppression(value = 2)
-      set_parameter :visu, value, :uint8  
-    end
-    alias visu set_vibration_suppression
-    
-    # Minimum Detection distance, 0 - 100% of Range setting, default = 0
-    def set_min_detection_distance(value = 0)
-      set_parameter :mira, value, :uint8
-    end
-    alias mira set_min_detection_distance
-    
-    # Maximum Detection distance, 0 - 100% of Range setting, default = 50
-    def set_max_detection_distance(value = 50)
-      set_parameter :mara, value, :uint8
-    end
-    alias mara set_max_detection_distance
-    
-    # Minimum Detection Angle, -90° - 90°, default = -90
-    def set_min_detection_angle(angle = -90)
-      set_parameter :mian, angle, :int8
-    end
-    alias mian set_min_detection_distance
-    
-    # Maximum Detection Angle, -90° - 90°, default = 90
-    def set_max_detection_angle(angle = 90)
-      set_parameter :maan, angle, :int8
-    end
-    alias maan set_max_detection_angle
-    
-    # Minimum Detection Speed, 0 - 100% of Speed setting, default = 0
-    def set_min_detection_speed(speed = 0)
-      set_parameter :misp, speed, :uint8
-    end
-    alias misp set_min_detection_speed
-    
-    # Maximum Detection Speed, 0 - 100% of Speed setting, default = 100
-    def set_max_detection_speed(speed = 100)
-      set_parameter :masp, speed, :uint8
-    end
-    alias masp set_max_detection_speed
-    
-    # Detection Direction, 0 = Receding, 1 = Approaching, 2 = Both (default)
-    def set_detection_direction(direction = 2)
-      set_parameter :dedi, direction, :uint8
-    end
-    alias dedi set_detection_direction
-    
-    # Range Threshold, 0 - 100% of Range setting, default = 10
-    def set_range_threshold(value = 10)
-      range = 0..100
-      return false unless range.include?(value)
-      
-      set_parameter :rath, value, :uint8
-    end
-    alias rath set_range_threshold
-    
-    # Angle Threshold, -90° to 90°, default = 0
-    def set_range_threshold(value = 0)
-      range = -90..90
-      return false unless range.include?(value)
-      
-      set_parameter :anth, value, :int8
-    end
-    alias anth set_range_threshold
-    
-    # Speed Threshold, 0 - 100% of speed setting, default = 50
-    def set_angle_threshold(value = 50)
-      range = 0..100
-      return false unless range.include?(value)
-      
-      set_parameter :spth, value, :uint8
-    end
-    alias spth set_angle_threshold
-    
-    # Digital output 1, 0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection, default = 0
-    def set_dio_1(value = 0)
-      range = 0..4
-      return false unless range.include?(value)
-      
-      set_parameter :dig1, value, :uint8
-    end
-    alias dig1 set_dio_1
-    
-    # Digital output 2, 0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection, default = 1
-    def set_dio_2(value = 1)
-      range = 0..4
-      return false unless range.include?(value)
-      
-      set_parameter :dig2, value, :uint8
-    end
-    alias dig2 set_dio_2
-    
-    # Digital output 3, 0 = Direction, 1 = Angle, 2 = Range, 3 = Speed, 4 = Micro Detection, default = 2
-    def set_dio_3(value = 2)
-      range = 0..4
-      return false unless range.include?(value)
-      
-      set_parameter :dig3, value, :uint8
-    end
-    alias dig3 set_dio_3
-    
-    # Hold Time, 1 - 7200s, default = 1
-    def set_hold_time(time = 1)
-      range = 1..7200
-      return false unless range.include?(time)
-      
-      set_parameter :hold, time, :uint16
-    end
-    alias hold set_hold_time
-    
-    # Micro Detection retrigger, 0 = Off (default), 1 = Retrigger
-    def set_micro_detection_retrigger(value = 0)
-      return false unless [0, 1].include?(value)
-      
-      set_parameter :mide, value, :uint8
-    end
-    alias mide set_micro_detection_retrigger
-    
-    # Micro Detection sensitivity, 0 - 9, 0 = Min, 9 = Max, default = 4
-    def set_micro_detection_sensitivty(value = 4)
-      range = 0..9
-      return false unless range.include?(value)
-      
-      set_parameter :mids, value, :uint8
-    end
-    alias mids set_micro_detection_sensitivty
-
-    private
-    
-    def set_parameter(header, value, return_type = :uint8)
-      return_type =
-        case return_type
-          when :uint8
-          'L'
-          when :int8
-          'l'
-          when :uint16
-          'S'
-          else
-          'L'
-        end
-      command = [header.upcase.to_s, 4, value]
-      write command.pack("a4L#{return_type}")
-      check_response
-    end
-  end
-end

data/lib/rfbeam/kld7/app_messages.rb

@@ -1,100 +0,0 @@
-module RfBeam
-  module KLD7
-    def detection?
-      data = ddat
-      (data[2] == 1)
-    end
-    
-    def pdat(formatted: false)
-      request_frame_data(:pdat)      
-      resp = read(102).unpack('a4LSssSSssSSssSSssSSssSSssSSssSSssSSssSSssS')
-      return resp unless formatted
-
-      target_count = resp[1].to_i / 8
-      return [] unless target_count > 0
-
-      resp.shift 2
-      resp.compact
-      detected_raw_targets = []
-      target_count.times { detected_raw_targets << format_raw_target_data(resp.shift(4)) }
-      detected_raw_targets
-    end
-
-    def tdat
-      request_frame_data(:tdat)
-
-      sleep 0.1
-      resp = read(16).unpack('a4LSssS')
-      return { dist: resp[2], speed: resp[3], angle: resp[4], mag: resp[5] } unless resp[1].zero?
-    end
-
-    def ddat
-      request_frame_data(:ddat)
-
-      read(14).unpack('a4LC6')
-    end
-    
-    def config
-      puts formatted_grps(grps)
-    end
-    
-    def formatted_parameter(param)
-      return unless PARAMETERS.include? param
-      
-      param_data = PARAMETERS[param]
-      grps_data = grps
-      index = grps_data[param_data[:grps_index]]
-      param_data[:values][index]
-    end
-
-    # Get the radar parameter structure
-    def grps
-      command = ['GRPS', 0]
-      write command.pack('a4L')
-      check_response
-      read(50).unpack('a4LA19C8c2C4cCCCCSCC')
-    end
-    
-
-    private
-
-    def format_raw_target_data(array)
-        { dist: array.shift, speed: array.shift, angle: array.shift, mag: array.shift }
-    end
-
-    def request_frame_data(type)
-      command = ['GNFD', 4, FRAME_DATA_TYPES[type]]
-      write command.pack('a4LL')
-      check_response
-    end
-
-    def formatted_grps(data)
-      output = "\n"
-      output << "Software Version: #{data[2]}\n"
-      output << "Base Frequency: #{PARAMETER_STRUCTURE[:base_frequency][data[3]]}\n"
-      output << "Max Speed: #{PARAMETER_STRUCTURE[:max_speed][data[4]]}\n"
-      output << "Max Range: #{PARAMETER_STRUCTURE[:max_range][data[5]]}\n"
-      output << "Threshold offset: #{data[6]}db\n"
-      output << "Tracking Filter Type: #{PARAMETER_STRUCTURE[:tracking_filter_type][data[7]]}\n"
-      output << "Vibration Suppression: #{data[8]} , (#{PARAMETER_STRUCTURE[:vibration_suppression]})\n"
-      output << "Minimum Detection Distance: #{data[9]} , (#{PARAMETER_STRUCTURE[:min_detection_distance]})\n"
-      output << "Maximum Detection Distance: #{data[10]} , (#{PARAMETER_STRUCTURE[:max_detection_distance]})\n"
-      output << "Minimum Detection Angle: #{data[11]}° , (#{PARAMETER_STRUCTURE[:min_detection_angle]})\n"
-      output << "Maximum Detection Angle: #{data[12]}° , (#{PARAMETER_STRUCTURE[:max_detection_angle]})\n"
-      output << "Minimum Detection Speed: #{data[13]} , (#{PARAMETER_STRUCTURE[:min_detection_speed]})\n"
-      output << "Maximum Detection Speed: #{data[14]} , (#{PARAMETER_STRUCTURE[:max_detection_speed]})\n"
-      output << "Detection Direction: #{PARAMETER_STRUCTURE[:detection_direction][data[15]]}\n"
-      output << "Range Threshold: #{data[16]}%, (#{PARAMETER_STRUCTURE[:range_threshold]})\n"
-      output << "Angle Threshold: #{data[17]}°, (#{PARAMETER_STRUCTURE[:angle_threshold]})\n"
-      output << "Speed Threshold: #{data[18]}%, (#{PARAMETER_STRUCTURE[:speed_threshold]})\n"
-      output << "Digital output 1: #{PARAMETER_STRUCTURE[:digital_output_1][data[19]]}\n"
-      output << "Digital output 2: #{PARAMETER_STRUCTURE[:digital_output_2][data[20]]}\n"
-      output << "Digital output 3: #{PARAMETER_STRUCTURE[:digital_output_3][data[21]]}\n"
-      output << "Hold time: #{data[22]}sec\n"
-      output << "Micro Detection Retrigger: #{PARAMETER_STRUCTURE[:micro_detection_trigger][data[23]]}\n"
-      output << "Micro Detection Sensitivity: #{data[24]} (#{PARAMETER_STRUCTURE[:micro_detection_sensitivity]})"
-      
-      output
-    end
-  end
-end