rfbeam 0.5.1 → 0.5.8

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

data/lib/rfbeam/kld7/operation_params.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+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).cover?(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).cover?(range)
+      raise ArgumentError, 'Expected an Integer' unless range.is_a?(Integer)
+
+      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).cover?(offset)
+      raise ArgumentError, 'Expected an Integer' unless offset.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 tracking_filter=(type = 0)
+      raise ArgumentError, "Invalid arg: '#{type}'" unless (0..2).cover?(type)
+      raise ArgumentError, 'Expected an Integer' unless type.is_a?(Integer)
+
+      set_parameter :trft, type, :uint32
+    end
+    alias trtf= tracking_filter=
+    alias set_tracking_filter 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).cover?(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=
+  end
+
+  # -----------------
+  # 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).cover?(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).cover?(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).cover?(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=
+end

data/lib/rfbeam/kld7/radar_messages.rb

@@ -1,7 +1,9 @@
-require "csv"
+# frozen_string_literal: true
+
+require 'csv'
 
 module RfBeam
-  module Kld7
+  module KLD7
     def detection?
       data = ddat
       (data[2] == 1)
@@ -10,55 +12,47 @@ module RfBeam
     def rfft
       request_frame_data(:rfft)
       sleep MEASUREMENT_DELAY
-      data = read(1032).unpack("a4LS256S256")
+      data = read(1032).unpack('a4LS256S256')
       header, length = data.shift(2)
-      unless header == "RFFT"
-        raise Error, "RFFT header response, header=#{header}"
-      end
+      raise Error, "RFFT header response, header=#{header}" unless header == 'RFFT'
       raise Error, "RFFT payload length, length=#{length}" unless length == 1024
 
       data
     end
 
     def reset
-      command = ["RFSE", 0]
-      write command.pack("a4L")
+      command = ['RFSE', 0]
+      write command.pack('a4L')
       check_response
     end
     alias rfse reset
 
     def pdat(formatted: false)
       request_frame_data(:pdat)
-      resp = read(102).unpack("a4LSssSSssSSssSSssSSssSSssSSssSSssSSssSSssS")
+      resp = read(102).unpack('a4LSssSSssSSssSSssSSssSSssSSssSSssSSssSSssS')
       return resp unless formatted
 
-      target_count = resp[1].to_i / 8
-      return [] unless target_count.positive?
+      target_count = Integer(resp[1], 10) / 8
+      return [] if target_count <= 0
 
       resp.shift 2
       resp.compact
       detected_raw_targets = []
-      target_count.times do
-        detected_raw_targets << format_raw_target_data(resp.shift(4))
-      end
+      target_count.times { detected_raw_targets << format_raw_target_data(resp.shift(4)) }
       detected_raw_targets
     end
 
     def tdat
       request_frame_data(:tdat)
-      sleep MEASUREMENT_DELAY
 
       sleep 0.1
-      resp = read(16).unpack("a4LSssS")
-      unless resp[1].zero?
-        return { dist: resp[2], speed: resp[3], angle: resp[4], mag: resp[5] }
-      end
+      resp = read(16).unpack('a4LSssS')
+      return { dist: resp[2], speed: resp[3], angle: resp[4], mag: resp[5] } if resp[1].nonzero?
     end
 
     def ddat
       request_frame_data(:ddat)
-      flags = %w[Low High]
-      array = read(14).unpack("a4LC6")
+      array = read(14).unpack('a4LC6')
       {
         label: array[0],
         detection: array[2] == 1,
@@ -73,21 +67,16 @@ module RfBeam
 
     # Get the radar parameter structure
     def grps
-      command = ["GRPS", 0]
-      write command.pack("a4L")
+      command = ['GRPS', 0]
+      write command.pack('a4L')
       check_response
-      read(50).unpack("a4LA19C8c2C4cCCCCSCC")
+      read(50).unpack('a4LA19C8c2C4cCCCCSCC')
     end
 
     def config
       data = grps
       output = "\n"
-      RADAR_PARAMETERS.keys.each do |key|
-        output << formatted_parameter(
-          key,
-          data[RADAR_PARAMETERS[key].grps_index]
-        )
-      end
+      RADAR_PARAMETERS.each_key { |key| output << formatted_parameter(key, data[RADAR_PARAMETERS[key].grps_index]) }
       output
     end
 
@@ -97,24 +86,19 @@ module RfBeam
         data = grps
         value = data[param.grps_index]
       end
-      param_str_value = param.str_values.empty? ? value.to_s : param.str_values[value]
+      param_str_value = param.values.empty? ? value.to_s : param.values[value]
       "#{param.name}: #{param_str_value}#{param.units}\n"
     end
 
     private
 
     def format_raw_target_data(array)
-      {
-        dist: array.shift,
-        speed: array.shift,
-        angle: array.shift,
-        mag: array.shift
-      }
+      { 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")
+      command = ['GNFD', 4, FRAME_DATA_TYPES[type]]
+      write command.pack('a4LL')
       check_response
     end
   end

data/lib/rfbeam/kld7/serial_connection.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module RfBeam
-  module Kld7
+  module KLD7
     require 'rubyserial'
     require 'timeout'
 
@@ -16,7 +16,6 @@ module RfBeam
       parity = :even
       stop_bits = 1
       open_serial_port(path, baude_rate, data_bits, parity, stop_bits)
-      init_radar if connected?
 
       yield self if block_given?
     end
@@ -42,6 +41,12 @@ module RfBeam
       sleep 0.1
     end
 
+    def init_radar
+      command = ['INIT', 4, 0]
+      @serial_port.write command.pack('a4LL')
+      check_response
+    end
+
     private
 
     def open_serial_port(path, baude_rate, data_bits, parity, stop_bits)
@@ -49,7 +54,7 @@ module RfBeam
     end
 
     def connected?
-      raise Error, 'ConnectionError: No open Serial device connections.' if @serial_port.nil?
+      raise Error, 'ConnectionError: No open Serial device connections.' if @serial_port.closed?
 
       true
     end
@@ -70,22 +75,16 @@ module RfBeam
       end
     end
 
-    def init_radar
-      command = ['INIT', 4, 0]
-      @serial_port.write command.pack('a4LL') # 4 ASCII bytes, UINT32, UINT32
-      check_response
-    end
-
     def check_response
       sleep RESPONSE_DELAY
-      resp = @serial_port.read(9).unpack('a4LC') # 4 ASCII bytes, UINT32, UINT8
+      resp = @serial_port.read(9).unpack('a4LC')
       raise Error, 'No valid response from Serial Port' if resp[2].nil?
 
-      response_key = resp[2]
-      error_string = RESP_CODES[response_key].nil? ? 'Response unknown' : RESP_CODES[response_key]
-      raise Error, "Radar response Error: #{error_string}" unless response_key.zero?
+      resp_code = resp[2]
+      index_range = 1..RESP_CODES.size
 
-      response_key.zero? # Everything OK
+      raise Error, "Radar response Error: #{RESP_CODES[resp_code]}" if index_range.include?(resp_code)
+      true
     end
   end
 end

data/lib/rfbeam/kld7/streamer.rb

@@ -1,8 +1,9 @@
-# rubocop:disable all
-require "unicode_plot"
-require "io/console"
-require "stringio"
-require "tty-screen"
+# frozen_string_literal: true
+
+require 'io/console'
+require 'stringio'
+require 'tty-screen'
+require 'unicode_plot'
 
 module RfBeam
   module KLD7
@@ -15,8 +16,8 @@ module RfBeam
 
       def monitor_keypress
         loop do
-          key = STDIN.getch
-          if key.downcase == "q"
+          key = $stdin.getch
+          if key.casecmp('q').zero?
             @stop_streaming = true
             break
           end
@@ -54,7 +55,7 @@ module RfBeam
         {
           x: Array(-128...128),
           series1: data.shift(256).map { |value| value / 100 },
-          series2: data.shift(256).map { |value| value.to_i / 100 }
+          series2: data.shift(256).map { |value| Integer(value, 10) / 100 }
         }
       end
 
@@ -65,16 +66,16 @@ module RfBeam
           UnicodePlot.lineplot(
             data[:x],
             data[:series1],
-            name: "IF1/2 Averaged",
-            title: "Raw FFT",
+            name: 'IF1/2 Averaged',
+            title: 'Raw FFT',
             height: 25,
-            width: width,
-            xlabel: "Speed (km/h)",
-            ylabel: "Signal (db)",
+            width:,
+            xlabel: 'Speed (km/h)',
+            ylabel: 'Signal (db)',
             xlim: [-128, 128],
             ylim: [0, 100]
           )
-        UnicodePlot.lineplot!(plot, data[:x], data[:series2], name: "Threshold")
+        UnicodePlot.lineplot!(plot, data[:x], data[:series2], name: 'Threshold')
         plot
       end
     end

data/lib/rfbeam/version.rb

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