rfbeam 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19f39170dee64099fe6806a345393beff434035df70fe525fa31b361468cac9e
-  data.tar.gz: 622aba1c5ab9f85fdb8cadf90f10339344306db39ab9299b2ef8b437d228d82d
+  metadata.gz: 7edface1b941c801c5842d40d396f8343461271f10a7c381346338e415b074e9
+  data.tar.gz: 02bf778dc66bb874da0323867beeb350d5a69e8bb8aa3986c140a88370ae4d94
 SHA512:
-  metadata.gz: 57bd136ef560a32dab06e08c841b44e6e1b192525d9d3d44db1a88885c0b30b9b9b28ab28b1f408d628e191195373a012d31405ae24372fa4efd76ecbb3af46c
-  data.tar.gz: 5dc08c9c71c511e210a4c30599248bb5be53f1ccd7373af73edeb1ff35043dc76b90235bf46de93b9b755123af598225d6b96f06f6c0c5ab89bf4d1bc2e81d57
+  metadata.gz: 0d4cac38cff0bcc30df6501bc42c2cfcc054df8df5d94b486489d1b123d44afce4d5fc49f42e14efbb66813caa12aca4e6d7c67dcdd4c6c9438dfaf698591a51
+  data.tar.gz: ee253b692da85a7504a0de62353fca8d060d1618d9b265f0afd28b32416892fc5754eb57db09af996d8b2fe766a96b84fa6b49d8d7cd4f3675d8ec338cc1e9d0

data/.rubocop.yml

@@ -1,11 +1,9 @@
-inherit_from:
-  - node_modules/@prettier/plugin-ruby/rubocop.yml
-
 AllCops:
   TargetRubyVersion: 3.2
 
 Layout/LineLength:
   Max: 120
+  AutoCorrect: true
 
 Metrics/ModuleLength:
   Enabled: false
@@ -13,5 +11,8 @@ Metrics/ModuleLength:
 Metrics/MethodLength:
   Max: 20
 
+Metrics/ClassLength:
+  Enabled: false
+
 Documentation:
   Enabled: false

data/.streerc

@@ -0,0 +1,2 @@
+--print-width=120
+--plugins=plugin/single_quotes

data/Gemfile

@@ -20,3 +20,7 @@ gem "unicode_plot", "~> 0.0.5"
 gem "tty-logger", "~> 0.6.0"
 
 gem "tty-screen", "~> 0.8.1"
+
+gem "tty-option", "~> 0.2.0"
+
+gem "tty-command", "~> 0.10.1"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rfbeam (0.4.0)
+    rfbeam (0.4.1)
       activesupport (~> 6.1.0)
       rubyserial (~> 0.6.0)
       thor (~> 1.2.1)
@@ -54,9 +54,12 @@ GEM
     strings-ansi (0.2.0)
     thor (1.2.1)
     tty-color (0.6.0)
+    tty-command (0.10.1)
+      pastel (~> 0.8)
     tty-cursor (0.7.1)
     tty-logger (0.6.0)
       pastel (~> 0.8)
+    tty-option (0.2.0)
     tty-screen (0.8.1)
     tty-spinner (0.9.3)
       tty-cursor (~> 0.7)
@@ -81,7 +84,9 @@ DEPENDENCIES
   rake (~> 13.0)
   rfbeam!
   rubocop (~> 1.21)
+  tty-command (~> 0.10.1)
   tty-logger (~> 0.6.0)
+  tty-option (~> 0.2.0)
   tty-screen (~> 0.8.1)
   tty-spinner (~> 0.9.3)
   tty-table (~> 0.12.0)

data/lib/rfbeam/cli.rb

@@ -1,4 +1,3 @@
-# rubocop:disable all
 require 'thor'
 require 'rfbeam'
 require 'tty-table'
@@ -9,122 +8,78 @@ require 'unicode_plot'
 
 module RfBeam
   class CLI < Thor
-  
     attr_accessor :radar, :logger
 
     desc 'list', 'List available radar modules'
     def list
+      logger = TTY::Logger.new
       devices = RfBeam.connected
-      @logger.warning 'No Radar modules found.' unless devices.count.positive?
+      logger.warning 'No Radar modules found.' unless devices.count.positive?
 
-      table = TTY::Table.new( header: ['id', 'Path', 'Version'])
+      table = TTY::Table.new(header: %w[id Path Version])
 
-      devices.each.with_index do |path, index|
-        table << ["R#{index}", path, @radar.sw_version]
-      end
+      devices.each.with_index { |path, index| table << ["#{index}", path, radar(index).sw_version] }
       puts table.render(:ascii)
     end
 
     desc 'config <radar_id>', 'Shows the parameter setting for the Radar module'
     def config(radar_id)
-      init_radar(radar_id)
-      puts @radar.config
+      puts radar(radar_id).config
+    end
+
+    desc 'reset <radar_id>', 'Shows the parameter setting for the Radar module'
+    def reset(radar_id)
+      @logger.success 'Radar reset to factory defaults' if radar(radar_id).reset
     end
 
     desc 'set_param <radar_id> <key> <value>', 'Set radar parameters, see readme for keys'
     def set_param(radar_id, param, value)
-      return logger.warning("Invalid param: '#{param}'") unless RfBeam::K_ld7::RADAR_PARAMETERS.include?(param.to_sym)
+      return @logger.warn("Invalid param: '#{param}'") unless RfBeam::K_ld7::RADAR_PARAMETERS.include?(param.to_sym)
 
-      init_radar radar_id
-      @radar.send("#{param}=", value.to_i)
-      logger.success "Set #{@radar.formatted_parameter(param.to_sym)}"
+      r = radar(radar_id)
+      r.send("#{param}=", value.to_i)
+      @logger.success r.formatted_parameter(param.to_sym)
     end
 
     desc 'ddat <radar_id>', 'stream any valid detections, stop stream with q and enter'
-    option :stream, type: :boolean, aliases: '-s', desc: "Stream the data from the device"
+    option :stream, type: :boolean, aliases: '-s', desc: 'Stream the data from the device'
     def ddat(radar_id)
-      init_radar radar_id
-      
-      if options[:stream]
-        Thread.new { monitor_keypress }
-        spinner = TTY::Spinner.new("[:spinner] :title ", format: :bouncing_ball)
-        loop do
-          break if @stop_streaming
-            spinner.spin
-            data = @radar.ddat
-            spinner.update title: "Searching... #{data}"
-            spinner.success @radar.tdat if data[2] == 1
-        end
-        spinner.stop
-        puts "\nTask Quit."
-      else
-          puts "\n#{@radar.ddat}"
-      end
-
+      cli = RfBeam::KLD7::CliOutput.new(radar_id)
+      cli.display(:ddat, stream: options[:stream])
     end
 
     desc 'pdat <radar_id>', 'Display Tracked Targets'
     def pdat(radar_id)
-      init_radar radar_id
-      puts @radar.pdat
+      cli = RfBeam::KLD7::CliOutput.new(radar_id)
+      cli.display(:pdat, stream: options[:stream])
     end
 
-    desc "rfft <radar_id>", "Display the dopplar radar data as a plot"
-    option :stream, type: :boolean, aliases: '-s', desc: "Stream the data from the device"
-    option :period, type: :numeric, aliases: '-p', default: 0.5, desc: "Update period (in seconds) for the streaming data"
+    desc 'rfft <radar_id>', 'Display the dopplar radar data as a plot'
+    option :stream, type: :boolean, aliases: '-s', desc: 'Stream the data from the device'
+    option :raw, type: :boolean, aliases: '-r', desc: 'Display raw data'
     def rfft(radar_id)
-      init_radar(radar_id)
-
-      if options[:stream]
-        streamer = RfBeam::KLD7::Streamer.new(@radar)
-        streamer.rfft
+      plotter = RfBeam::KLD7::CliOutput.new(radar_id)
+      if options[:raw]
+        print radar(radar_id).rfft
       else
-        plot = rfft_plot(@radar)
-        p plot.render
+        plotter.plot(:rfft, stream: options[:stream])
       end
     end
 
+    desc 'tdat <radar_id>', 'Display tracked target data'
+    def tdat(radar_id)
+      cli = RfBeam::KLD7::CliOutput.new(radar_id)
+      cli.display(:tdat, stream: options[:stream])
+    end
+
     private
 
-    def init_radar(id)
+    def radar(id)
       devices = RfBeam.connected
       @logger = TTY::Logger.new
       return @logger.warning 'No Radar modules found.' unless devices.count.positive?
 
-      @radar = RfBeam::K_ld7.new(devices[id.to_i])
-    end
-
-    def plot_data(data)
-      { x: Array(-128...128), series1: data.shift(256).map { |value| value / 100 }, series2: data.shift(256).map { |value| value.to_i / 100 } }
-    end
-
-    def monitor_keypress
-      loop do
-        key = STDIN.getch
-        if key.downcase == 'q'
-          @stop_streaming = true
-          break
-        end
-      end
-    end
-
-    def rfft_plot(radar)
-      speed = radar.max_speed
-      speed_label = radar.formatted_parameter(:max_speed)
-      xlim = [speed - speed * 2, speed]
-      data = plot_data(radar.rfft)
-      plot = UnicodePlot.lineplot(
-        data[:x],
-        data[:series1],
-        name: 'IF1/2 Averaged',
-        title: 'Raw FFT',
-        height: 25,
-        width: 120,
-        xlabel: "Speed (km/h), #{speed_label}",
-        ylabel: 'Signal (db)', xlim: [-128, 128],
-        ylim: [0, 100])
-      UnicodePlot.lineplot!(plot, data[:x], data[:series2], name: "Threshold")
-      plot
+      RfBeam::K_ld7.new(devices[id.to_i])
     end
   end
-end
+end

data/lib/rfbeam/kld7/cli_formatter.rb

@@ -0,0 +1,41 @@
+require 'tty-table'
+
+module RfBeam
+  module KLD7
+    class CliFormatter
+      def tdat(data)
+        { dist: data[2], speed: data[3], angle: data[4], mag: data[5] }
+      end
+
+      def pdat_table(data)
+        table = TTY::Table.new header: ['index', 'dist (M)', 'speed (Km/h)', 'angle (°)', 'mag (db)']
+        count = data[1] / 8
+        data.shift(2)
+        count.times.with_index do |index|
+          values = data.shift(4).map { |value| value.to_f / 100.0 }
+          table << [index, values].flatten
+        end
+        table
+      end
+
+      def ddat(data)
+        if data[2] == 1
+          labels = ['Detection', 'Micro Detection', 'Angle', 'Direction', 'Range', 'Speed']
+          labels
+            .map
+            .with_index { |label, index| "#{label}: #{DETECTION_FLAGS[to_symbol(label)][data[index + 2]]}" }
+            .join("\n")
+        else
+          'DDAT: No Detection'
+        end
+      end
+
+      private
+
+      def to_symbol(string)
+        modified_string = string.gsub(' ', '_').downcase
+        modified_string.to_sym
+      end
+    end
+  end
+end

data/lib/rfbeam/kld7/cli_output.rb

@@ -0,0 +1,127 @@
+require 'unicode_plot'
+require 'io/console'
+require 'stringio'
+require 'tty-screen'
+require 'tty-logger'
+
+module RfBeam
+  module KLD7
+    class CliOutput
+      attr_reader :radar
+
+      def initialize(radar_id)
+        devices = RfBeam.connected
+        return TTY::Logger.new.warning 'No Radar modules found.' unless devices.count.positive?
+
+        @radar = RfBeam::K_ld7.new(devices[radar_id.to_i])
+      end
+
+      def display(type, stream: false)
+        send("display_#{type}", stream)
+      end
+
+      def plot(type, stream: false)
+        stream ? stream_plot(type) : display_plot(type)
+      end
+
+      def display_plot(type)
+        out = StringIO.new
+        def out.tty?
+          true
+        end
+        out.truncate(0)
+
+        plot = send("#{type}_plot")
+        plot.render(out)
+
+        lines = out.string.lines
+        lines.each { |line| $stdout.print "\r#{line}" }
+        $stdout.print "\e[0J"
+        $stdout.flush
+
+        if @streaming
+          n = lines.count
+          $stdout.print "\e[#{n}F"
+        end
+      end
+
+      def stream_plot(type)
+        @streaming = true
+        Thread.new { monitor_keypress }
+
+        loop do
+          display_plot(type)
+          break unless @streaming
+        end
+      end
+
+      private
+
+      def monitor_keypress
+        loop do
+          key = STDIN.getch
+          if key.downcase == 'q'
+            @streaming = false
+            break
+          end
+        end
+      end
+
+      def rfft_plot_data(data)
+        {
+          x: Array(-128...128),
+          series1: data.shift(256).map { |value| value / 100 },
+          series2: data.shift(256).map { |value| value.to_i / 100 }
+        }
+      end
+
+      def display_ddat(stream)
+        if stream
+          @streaming = true
+          Thread.new { monitor_keypress }
+          spinner = TTY::Spinner.new('[:spinner] :title ', format: :bouncing_ball)
+          logger = TTY::Logger.new
+          loop do
+            break unless @streaming
+            spinner.spin
+            data = @radar.ddat
+            spinner.update title: "Searching... #{data[:detection_str]}"
+            logger.success "#{@radar.tdat}" if data[:detection]
+          end
+        else
+          puts RfBeam::KLD7::CliFormatter.new.ddat(@radar.ddat)
+        end
+      end
+
+      def display_tdat(stream)
+        puts RfBeam::KLD7::CliFormatter.new.tdat(@radar.tdat)
+      end
+
+      def display_pdat(stream)
+        table = RfBeam::KLD7::CliFormatter.new.pdat_table(@radar.pdat)
+        puts "\n   Detected Raw Targets"
+        puts table.render(:unicode, alignment: :center)
+      end
+
+      def rfft_plot
+        width = TTY::Screen.width * 0.65
+        data = rfft_plot_data(@radar.rfft)
+        plot =
+          UnicodePlot.lineplot(
+            data[:x],
+            data[:series1],
+            name: 'IF1/2 Averaged',
+            title: 'Raw FFT',
+            height: 25,
+            width: width,
+            xlabel: 'Speed (km/h)',
+            ylabel: 'Signal (db)',
+            xlim: [-128, 128],
+            ylim: [0, 100]
+          )
+        UnicodePlot.lineplot!(plot, data[:x], data[:series2], name: 'Threshold')
+        plot
+      end
+    end
+  end
+end

data/lib/rfbeam/kld7/constants.rb

@@ -14,52 +14,176 @@ module RfBeam
       6 => 'Timeout error'
     }.freeze
 
-    # The response delay was determined empirically and may need adjusting with baude rate
-    RESP_DELAY = 0.1
+    # Delays are determined empirically and may need adjusting with baude rate
+    RESPONSE_DELAY = 0.05
+    MEASUREMENT_DELAY = 0.15
 
     # 'GNFD' command types
     FRAME_DATA_TYPES = { disabled: 0x00, radc: 0x01, rfft: 0x02, pdat: 0x04, tdat: 0x08, ddat: 0x10, done: 0x20 }.freeze
 
     # The angle, direction, range and speed flags are only valid if the detection flag is 1.
     DETECTION_FLAGS = {
-      detection: ['No Detection', 'Detection'],
-      micro_detection: ['No Detection', 'Detection'],
+      detection: ['No', 'Yes'],
+      micro_detection: ['No', 'Yes'],
       angle: %w[Left Right],
       direction: %w[Receding Approaching],
       range: %w[Far Near],
       speed: %w[Low High]
     }.freeze
 
-    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:)
+    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, 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] ),
-      threshold_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
+      base_frequency:
+        Param.new(
+          name: 'Base Frequency',
+          grps_index: 3,
+          description: '0 = Low, 1 = Middle, 2 = High',
+          default: 1,
+          values: %w[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: %w[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]
+        ),
+      threshold_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
   end
 end

data/lib/rfbeam/kld7/radar_messages.rb

@@ -9,15 +9,27 @@ module RfBeam
 
     def rfft
       request_frame_data(:rfft)
+      sleep MEASUREMENT_DELAY
+      data = read(1032).unpack('a4LS256S256')
+      header, length = data.shift(2)
+      raise Error, "RFFT header response, header=#{header}" unless header == 'RFFT'
+      raise Error, "RFFT payload length, length=#{length}" unless length == 1024
 
-      resp = read(1032).unpack('a4LS256S256')
-      resp.shift 2
-      resp
+      data
+    end
+
+    def reset
+      command = ['RFSE', 0]
+      write command.pack('a4L')
+      check_response
     end
-    
+    alias rfse reset
+
     def pdat(formatted: false)
-      request_frame_data(:pdat)      
+      request_frame_data(:pdat)
       resp = read(102).unpack('a4LSssSSssSSssSSssSSssSSssSSssSSssSSssSSssS')
+      raise Error, "PDAT response = #{resp[0]}" unless resp[0] == 'PDAT'
+
       return resp unless formatted
 
       target_count = resp[1].to_i / 8
@@ -32,26 +44,23 @@ module RfBeam
 
     def tdat
       request_frame_data(:tdat)
+      sleep MEASUREMENT_DELAY
 
-      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?
+      raise Error, "TDAT response = #{resp[0]}" unless resp[0] == 'TDAT'
+
+      resp
     end
 
     def ddat
       request_frame_data(:ddat)
-      flags = %w[Low High]
-      array = read(14).unpack('a4LC6')
-      { label: array[0],
-      detection: DETECTION_FLAGS[:detection][array[2]],
-      micro_detection: DETECTION_FLAGS[:micro_detection][array[3]],
-      angle: DETECTION_FLAGS[:angle][array[4]],
-      direction: DETECTION_FLAGS[:direction][array[5]],
-      range: DETECTION_FLAGS[:range][array[6]],
-      speed: DETECTION_FLAGS[:speed][array[7]]
-    }
+      sleep MEASUREMENT_DELAY
+
+      resp = read(14).unpack('a4LC6')
+      raise Error, "DDAT response = #{resp[0]}" unless resp[0] == 'DDAT'
+      resp
     end
-    
+
     # Get the radar parameter structure
     def grps
       command = ['GRPS', 0]
@@ -63,12 +72,10 @@ module RfBeam
     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.keys.each { |key| output << formatted_parameter(key, data[RADAR_PARAMETERS[key].grps_index]) }
       output
     end
-    
+
     def formatted_parameter(param, value = nil)
       param = RADAR_PARAMETERS[param]
       if value.nil?
@@ -82,7 +89,7 @@ module RfBeam
     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)

data/lib/rfbeam/kld7/serial_connection.rb

@@ -75,7 +75,7 @@ module RfBeam
     end
 
     def check_response
-      sleep RESP_DELAY
+      sleep RESPONSE_DELAY
       resp = @serial_port.read(9).unpack('a4LC') # 4 ASCII bytes, UINT32, UINT8
       raise Error, 'No valid response from Serial Port' if resp[2].nil?
 

data/lib/rfbeam/version.rb

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

data/lib/rfbeam.rb

@@ -4,11 +4,11 @@ require 'rfbeam/kld7/radar_parameters'
 require 'rfbeam/kld7/radar_messages'
 require 'rfbeam/kld7/serial_connection'
 require 'rfbeam/kld7/constants'
-require 'rfbeam/kld7/streamer'
+require 'rfbeam/kld7/cli_output'
+require 'rfbeam/kld7/cli_formatter'
 require 'rfbeam/version'
 require 'rfbeam/cli'
 
-
 module RfBeam
   class Error < StandardError
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rfbeam
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Rob Carruthers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-04-04 00:00:00.000000000 Z
+date: 2023-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -62,6 +62,7 @@ extra_rdoc_files: []
 files:
 - ".DS_Store"
 - ".rubocop.yml"
+- ".streerc"
 - ".tool-versions"
 - CHANGELOG.md
 - Gemfile
@@ -72,11 +73,12 @@ files:
 - exe/rfbeam
 - lib/rfbeam.rb
 - lib/rfbeam/cli.rb
+- lib/rfbeam/kld7/cli_formatter.rb
+- lib/rfbeam/kld7/cli_output.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/kld7/streamer.rb
 - lib/rfbeam/version.rb
 - node_modules/.bin/prettier
 - node_modules/.yarn-integrity

data/lib/rfbeam/kld7/streamer.rb

@@ -1,75 +0,0 @@
-# rubocop:disable all
-require 'unicode_plot'
-require 'io/console'
-require "stringio"
-require 'tty-screen'
-
-module RfBeam
-  module KLD7
-    class Streamer
-      attr_accessor :radar
-
-      def initialize(radar)
-        @radar = radar
-      end
-
-      def monitor_keypress
-        loop do
-          key = STDIN.getch
-          if key.downcase == "q"
-            @stop_streaming = true
-            break
-          end
-        end
-      end
-      
-      def rfft
-        out = StringIO.new
-        def out.tty?
-          true
-        end
-
-        Thread.new { monitor_keypress }
-
-        loop do
-          out.truncate(0)
-
-          plot = rfft_plot(@radar)
-          plot.render(out)
-
-          lines = out.string.lines
-          lines.each { |line| $stdout.print "\r#{line}" }
-          $stdout.print "\e[0J"
-          $stdout.flush
-          break if @stop_streaming
-
-          n = lines.count
-          $stdout.print "\e[#{n}F"
-        end
-      end
-
-      private
-
-      def plot_data(data)
-        { x: Array(-128...128), series1: data.shift(256).map { |value| value / 100 }, series2: data.shift(256).map { |value| value.to_i / 100 } }
-      end
-
-      def rfft_plot(radar)
-        width = TTY::Screen.width * 0.65
-        data = plot_data(radar.rfft)
-        plot = UnicodePlot.lineplot(
-          data[:x],
-          data[:series1],
-          name: 'IF1/2 Averaged',
-          title: 'Raw FFT',
-          height: 25,
-          width: width,
-          xlabel: "Speed (km/h)",
-          ylabel: 'Signal (db)', xlim: [-128, 128],
-          ylim: [0, 100])
-        UnicodePlot.lineplot!(plot, data[:x], data[:series2], name: "Threshold")
-        plot
-      end
-    end
-  end
-end