my_gpsd_client 0.1.30 → 0.02.00

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ee600b4280ec136fb4493892c58b4bb008e33c1f8224ce20bbf1991ea534e469
-  data.tar.gz: 2b760c07a8cb3e090f2b4a2d53f11edbc3811425004e093e902913fdceeaba52
+  metadata.gz: 55ba906b7dbaf8ff492fb7a06409f631e4365f28afbad9ce304feb8c7be1e000
+  data.tar.gz: 72381fa6a0ee53da5880cba4e4c7d414296b9beab632890e6858814897f3eb4a
 SHA512:
-  metadata.gz: 9596d2cd259de9f857a47124e0b171be2a3378cc73b47de6b22e00eee3bea431caf15af18e97d4ace0864808c0c73325604887e3426ca5315d1400dc2efac105
-  data.tar.gz: 731aea1ff46f96c1c60909c4cf41c02c45772b5bf458f7177129df18fc6ca17cb220a318d2fc9de3f8a7cc24fd019ea75427e211ebc3da16beca8d922244300f
+  metadata.gz: 2a827c3021083ac68f84e622dad8812695e69ed8219f1bc7cb1e95dda40106efa3373715c4ecaec53ad2b335128110117b404b8bb99c075e9a08d99475314f32
+  data.tar.gz: cb009e38a29b6e0d2b2826a1d234d9b0e4c579d20025d52714844413fb74d18c33490d54672f7818677b4e13a191c8813d87a99c255c38005e379f86df1b94d3

data/.gitignore

@@ -6,3 +6,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+/log/

data/lib/my_gpsd_client.rb

@@ -2,12 +2,27 @@ require "my_gpsd_client/version"
 require 'socket'
 require 'json'
 require 'date'
+require 'logger'
 
 class MyGpsdClient
-  attr_accessor :host, :port, :watch, :verbose, :min_speed, :watchdog_max, :watchdog_force
-  attr_reader :version, :socket_ready, :msg_counts, :watchdog_fired_count
+  attr_accessor :host, :port, :command, :log_level, :min_speed, :watchdog_max, :watchdog_force
+  attr_reader :version, :last_watch, :socket_ready, :msg_counts, :watchdog_fired_count
+
+  DEFAULT_HOST = 'localhost'
+  DEFAULT_PORT = 2947
+  DEFAULT_WATCH = {"enable":false,"json":false,"nmea":false}
+  DEFAULT_LOG_LEVEL = 0
+  DEFAULT_WATCHDOG_MAX = 5.0
+  WATCHDOG_STEP = 0.1 # Check watchdog ten times per second
+
+  THREAD_NAMES = {    # Keep displayed names the same length
+    MainThread:       "MainThread ",
+    SocketInitThread: "SockInitThd",
+    WatchdogThread:   "WatchdogThd",
+    ReadThread:       "ReadThread "
+   }
+  Thread.current[:name]=THREAD_NAMES[:MainThread]
 
-  DEFAULT_WATCH = {"enable":true,"json":true,"nmea":false}
 
   # A simple gpsd client that dump's json objects contianing all info received from the gpsd deamon
   # you need to at least setup either the raw callback (on_raw_change) or position callback (on_position_change) to use GPSD2JSON. the raw callback just passes the json objects it received from the daemon on to the block you pass it. the on_position_change and on_satellites_change are a bit easier to use.
@@ -24,19 +39,20 @@ class MyGpsdClient
   # gps.start
   # #when done
   # gps.stop
-  def initialize(host: 'localhost', port: 2947, watch: DEFAULT_WATCH, verbose: false)
+  def initialize(host: DEFAULT_HOST, port: DEFAULT_PORT, watch: DEFAULT_WATCH, log_level: DEFAULT_LOG_LEVEL)
     @version = MyGpsdClient_version::VERSION
-    @verbose = verbose
-    @socket = nil
-    @socket_ready = false
     @host = host
     @port = port
-    @watch = watch
-    @trackthread = nil
+    @last_watch = watch
+    @log_level = log_level
+
+    @socket = nil
+    @socket_ready = false
+    @readthread = nil
     @socket_init_thread = nil
     @watchdog_thread = nil
-    @watchdog_count = 0
-    @watchdog_max = 10
+    @watchdog_count = 0.0
+    @watchdog_max = DEFAULT_WATCHDOG_MAX
     @watchdog_fired_count = 0
     @watchdog_force = false
     @min_speed = 0 # speed needs to be higher than this to make the gps info count
@@ -51,175 +67,243 @@ class MyGpsdClient
     @msg_counts = {wtch: 0, ver: 0, tpv: 0, sky: 0, gst: 0, att: 0,
                   toff: 0, pol: 0, pps: 0, dev: 0, devs: 0, err: 0,
                   unk: 0}
-    puts "Version: #{@version}" if @verbose
-  end
 
-  def on_raw_send(options:{}, &block)
-    @sent_raw_callback = block
+    MyGpsdClient.logger.progname = MyGpsdClient
+    MyGpsdClient.logger.level = @log_level
+    my_logger level: 'info', msg: "MyGpsdClient Gem - Version: #{@version}"
   end
 
-  # @param [Object] options Possible options to pass (not used yet)
-  # @param [Block] block Block to call when new json object comes from gpsd
-  def on_raw_change(options:{}, &block)
-      @json_raw_callback = block
+  #
+  # Receive Commands from User
+  #
+  def command=(val)
+    @command = val
+    my_logger level: 'info', msg:  "Command: Command received: #{@command}"
+    @last_watch = @command if @command[:class].casecmp? "WATCH"
+    send_cmmd
   end
 
-  # @param [Object] options Possible options to pass (not used yet)
-  # @param [Block] block Block to call when new gps position json object comes from gpsd
-  def on_position_change(options:{}, &block)
-      @json_pos_callback = block
+  def log_level=(val)
+    @log_level = val
+    MyGpsdClient.logger.level = @log_level
   end
 
-  # @param [Object] options Possible options to pass (not used yet)
-  # @param [Block] block Block to call when new satellite info json object comes from gpsd
-  def on_satellites_change(options:{}, &block)
-      @json_sat_callback = block
+  def log_marker level: 'debug', msg: "Log Marker"
+    my_logger level: level, msg: "~~~~~~~~~~~~~~~~~~~~~~~ #{msg} ~~~~~~~~~~~~~~~~~~~~~~~"
   end
 
-  # @param [Object] options Possible options to pass (not used yet)
-  # @param [Block] block Block to call when new pps info json object comes from gpsd
-  def on_pps_change(options:{}, &block)
-      @json_pps_callback = block
-  end
+  private
 
-  # @param [Object] options Possible options to pass (not used yet)
-  # @param [Block] block Block to call when new pps info json object comes from gpsd
-  def on_unk_change(options:{}, &block)
-      @json_unk_callback = block
-  end
-
-  def reset_msg_counts
-    @msg_counts.each_key { |k| @msg_counts[k] = 0 }
+  def send_cmmd
+    my_logger  msg:  "Entered Send_cmmd"
+    unless @socket_ready
+      my_logger  msg:  "Send_cmmd: Entering 'start'"
+      start
+      my_logger  msg:  "Send_cmmd: Wait for 'socket_init_thread' to completed"
+      @socket_init_thread.join  # wait for socket_ready
+      my_logger  msg:  "Send_cmmd: 'start' completed"
+    end
+    unless @socket_ready
+      my_logger  level: 'error', msg:  'Send_cmmd: Socket Initialization Error'
+    else
+      # it's ready, tell it to start watching and passing
+      my_logger  msg:  "Send_cmmd: socket ready, send cmmd"
+      str = "?#{@command[:class].upcase}=#{@command.to_json}"
+      my_logger level: 'info', msg:  "Send_cmmd: sending: #{str}"
+      @sent_raw_callback.call( str) if @sent_raw_callback
+      @socket.puts str
+      # If Enable was false in the last WATCH command, close the connecction
+      stop if @last_watch.key?(:enable) && !@last_watch[:enable]
+    end
+    my_logger  msg:  "Send_cmmd: Exiting send_cmmd"
   end
 
-  def self.version
-    MyGpsdClient_version::VERSION
-  end
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  #~~~~~~~~~~~~~~~~~~~~~~ PROCESS STARTUP ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
   # Open the socket and when ready request the position flow from the gps daemon
   def start
-      # background thread that is used to open the socket and wait for it to be ready
-      @socket_init_thread = Thread.start do
-          #open the socket
-          retry_count = 10
-          while (retry_count -= 1) > 0
-          #while not @socket_ready
-              init_socket
-              #wait for it to be ready
-              sleep 0.1
-              break if @socket_ready
-          end
+    my_logger  msg:  "Entered Start"
 
-          unless @socket_ready
-            puts 'Socket Initialization Error' if @verbose
-          else
-            # it's ready, tell it to start watching and passing
-            puts "socket ready, start watching" if @verbose
-            str = "?WATCH=#{@watch.to_json}"
-            puts "sending: #{str}" if @verbose
-            @sent_raw_callback.call( str) if @sent_raw_callback
-            @socket.puts str
-            #puts 'sending: ?WATCH={"enable":true,"json":true}' if @verbose
-            #@socket.puts '?WATCH={"enable":true,"json":true}'
-          end
+    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    # background thread that is used to open the socket and wait for it to be ready
+    my_logger  level: 'info', msg:  "Start: Starting Socket_init Thread"
+    @socket_init_thread = Thread.start do
+      Thread.current[:name]=THREAD_NAMES[:SocketInitThread]
+      my_logger  msg:  "Socket_init Thread"
+      #open the socket
+      retry_count = 0
+      #while not @socket_ready
+      while (retry_count += 1) <= 10 && !@socket_ready
+        my_logger  msg:  "Socket_init Thread: Socket Init Loop - Pass: #{retry_count}"
+        init_socket
+        my_logger  msg:  "Socket_init Thread: Return from init_socket - @socket_ready: #{@socket_ready}"
+        #wait for it to be ready
+        sleep 0.1
       end
+      my_logger  level: 'info', msg:  "Socket_init Thread: Exiting"
+    end
 
-      # background thead that is used to read info from the socket and use it
-      @trackthread = Thread.start do
-          while true do
-              begin
-                  read_from_socket
-              rescue
-                  "error while reading socket: #{$!}" if @verbose
-              end
-          end
+    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    # background thead that is used to read info from the socket and use it
+    my_logger  msg:  "Start: Starting readthread Thread"
+    @readthread = Thread.start do
+      Thread.current[:name]=THREAD_NAMES[:ReadThread]
+      my_logger  msg:  "Readthread Thread: #{Thread.current[:name]}"
+      my_logger  msg:  "Readthread: Wait for 'socket_init_thread' to completed"
+      # wait for socket_init_thread to complete so that @socket_ready will be true
+      @socket_init_thread.join if @socket_init_thread && @socket_init_thread.alive?
+      while @socket_ready do
+        begin
+          read_from_socket
+        rescue
+          my_logger  msg:  "Readthread Thread: Error while reading socket: #{$!}"
+        end
       end
+      my_logger level: 'warn', msg:  "Readthread Thread: Exiting, @socket_ready: #{@socket_ready}"
+    end
 
-      Thread.kill(@watchdogthread) if @watchdog_thread
-      @watchdogthread = Thread.start do
-        @watchdog_count = 0
-        while true do
-          if @watchdog_force
-            @watchdog_force = false
-            @watchdog_count = @watchdog_max
-          end
-          if (@watchdog_count += 1) >= @watchdog_max
-            @watchdog_count = 0
-            @watchdog_fired_count += 1
+    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+    # background thread to implement a watchdog timer
+    my_logger  msg:  "Start: Starting Watchdog Thread"
+    @watchdogthread = Thread.start do
+      Thread.current[:name]=THREAD_NAMES[:WatchdogThread]
+      my_logger  msg:  "Watchdog Thread: #{Thread.current[:name]}"
+      @watchdog_count = 0.0
+      @watchdog_enabled = true
+      while @watchdog_enabled do
+        if @watchdog_force
+          @watchdog_force = false
+          # force the watchdog to fire by killing the socket
+          @socket.close if @socket && !@socket.closed?
+          #@watchdog_count = @watchdog_max
+        end
+        if (@watchdog_count += WATCHDOG_STEP) >= @watchdog_max
+          my_logger level: 'warn', msg:  "Watchdog Fired"
+          @watchdog_count = 0.0
+          @watchdog_fired_count += 1
+          @watchdog_enabled = false
+          # Kill the readthread...
+          my_logger msg: "Watchdog Thread: Killing ReadThread"
+          Thread.kill(@readthread) if @readthread && @readthread.alive?
+          if @last_watch[:enable]
             stop
-            sleep 1
-            start
+            sleep 0.5
+            my_logger msg: "Watchdog Thread: Send Last_Watch: #{@last_watch}"
+            @command = @last_watch
+            send_cmmd
+            my_logger msg: "Watchdog Thread: Thread.exit"
+            Thread.exit
+          else
+            close_socket
           end
-          sleep 1
         end
-      end
+        sleep WATCHDOG_STEP
+      end   # while
+      my_logger msg: "Closing Watchdog Thread"
+    end   # watchdog thread
+    #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-  end
+    my_logger  msg:  "Start: Exiting Start"
+  end # def start
 
-  # @return [string] status info string containing nr satellites, fix, speed
-  def to_status
-      return "lat: #{last['lat']}, lng: #{last['lon']}, speed:#{last['speed']}, sats: #{@sats.length}(#{@sats.count{|sat| sat['used']}})" if @socket_ready and @last and @sats
-      return "lat: #{last['lat']}, lng: #{last['lon']}, speed:#{last['speed']}" if @socket_ready and @last and @sats.nil?
-      return "sats: #{@sats.length}(#{@sats.count{|sat| sat['used']}}), no fix yet" if @socket_ready and @last.nil? and @sats
-      return "connected with gpsd, waiting for data" if @socket_ready
-      return "waiting for connection with gpsd" if @socket_ready == false
-  end
+  # initialize gpsd socket
+  def init_socket
+    my_logger  msg:  "Entered Init_socket"
+    begin
+      close_socket if @socket && !@socket.closed?
 
-  # Stop the listening loop and close the socket. It will read the last bit of data from the socket, close it, and clean it up
-  def stop
-      # last read(s)
-      3.times { read_from_socket }
-      # then close
-      close_socket
-      # then cleanup
+      # Send the 'Hello' message (Content apparently irrelevant)
+      @socket = TCPSocket.new(@host, @port)
+      msg="This space for rent"
+      my_logger  level: 'info', msg:  "Init_socket: Sending Cmmd: \"#{msg}\""
+      @socket.puts(msg)
+      @sent_raw_callback.call( msg) if @sent_raw_callback
+
+      my_logger  msg:  "Init_socket: reading socket..."
+      welcome = ::JSON.parse @socket.gets.chomp
+      @json_raw_callback.call(welcome) if @json_raw_callback
+      my_logger  level: 'info', msg:  "Init_socket: Received welcome: #{welcome.inspect}"
+      @socket_ready = (welcome and welcome['class'] and welcome['class'] == 'VERSION')
+      @msg_counts[:ver] += 1 if @socket_ready
+      my_logger  level: 'info',msg:  "Init_socket: @socket_ready: #{@socket_ready.inspect}"
+    rescue
       @socket_ready = false
-      Thread.kill(@socket_init_thread) if @socket_init_thread
-      Thread.kill(@trackthread) if @trackthread
+      my_logger  level: 'error', msg:  "Init_socket: Rescue: #$!"
     end
+    my_logger  msg:  "Init_socket: Exiting init_socket"
+  end
 
-  # initialize gpsd socket
-  def init_socket
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  #~~~~~~~~~~~~~~~~~~~~~ PROCESS RUN THREAD ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+  # Read from socket. this should happen in a Thread as a continues loop. It should try to read data from the socket but nothing might happen if the gps deamon might not be ready. If ready it will send packets that we read and proces
+  def read_from_socket
+    my_logger  msg:  "Entered Read_from_socket"
+    if @socket_ready
+      my_logger  msg:  "Read_from_socket: Socket_ready"
       begin
-          puts "init_socket" if @verbose
-          close_socket if @socket
-          @socket = TCPSocket.new(@host, @port)
-          #msg="w+"
-          msg="This space for rent"
-          @sent_raw_callback.call( msg) if @sent_raw_callback
-          @socket.puts(msg)     #contents seem to be irrelevant here
-
-          puts "reading socket..." if @verbose
-          welcome = ::JSON.parse @socket.gets.chomp
-          @json_raw_callback.call(welcome) if @json_raw_callback
-          puts "welcome: #{welcome.inspect}" if @verbose
-          @socket_ready = (welcome and welcome['class'] and welcome['class'] == 'VERSION')
-          @msg_counts[:ver] += 1 if @socket_ready
-          puts "@socket_ready: #{@socket_ready.inspect}" if @verbose
+        if input = @socket.gets.chomp and not input.to_s.empty?
+            parse_socket_json(json: JSON.parse(input))
+            @watchdog_count = 0
+            my_logger level: 'info', msg:  "Read_from_socket: Read: #{input}"
+        else
+            sleep 0.1
+        end
       rescue
-          @socket_ready = false
-          puts "#$!" if @verbose
+        my_logger level: 'error', msg:  "Read_from_socket: error reading from socket: #{$!}"
+        @socket_ready = !@socket.closed? if @socket
       end
+    else
+      my_logger level: 'warn', msg:  "Read_from_socket: socket not ready"
+      sleep 0.1
+    end
+    my_logger  msg:  "Read_from_socket: Exiting"
   end
 
-  # Read from socket. this should happen in a Thread as a continues loop. It should try to read data from the socket but nothing might happen if the gps deamon might not be ready. If ready it will send packets that we read and proces
-  def read_from_socket
-      if @socket_ready
-          begin
-              if input = @socket.gets.chomp and not input.to_s.empty?
-                  parse_socket_json(json: JSON.parse(input))
-                  @watchdog_count = 0
-              else
-                  sleep 0.1
-              end
-          rescue
-              puts "error reading from socket: #{$!}" if @verbose
-          end
-      else
-          sleep 0.1
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  #~~~~~~~~~~~~~~~~~~~~~~~~ PROCESS SHUTDOWN ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  # Stop the listening loop and close the socket. It will read the last bit of data from the socket, close it, and clean it up
+  def stop
+    my_logger level: 'info', msg:  "Entered Stop"
+    # last read(s)
+    3.times { |c| my_logger(  msg:  "Read loop #{c+1}"); read_from_socket }
+    # then close
+    close_socket
+    my_logger level: 'info', msg:  "Exiting Stop"
+  end
+
+  # Close the gps deamon socket
+  def close_socket
+    mutex = Mutex.new
+    mutex.synchronize do
+      my_logger  msg:  "Entered CloseSocket"
+      begin
+        Thread.kill(@socket_init_thread) if @socket_init_thread && @socket_init_thread.alive?
+        Thread.kill(@readthread) if @readthread && @readthread.alive?
+        @socket_ready = false
+        @socket.close if @socket && !@socket.closed?
+        @socket = nil
+        Thread.kill(@watchdogthread) if @watchdog_thread && @watchdog_thread.alive? && Thread.current[:name] != THREAD_NAMES[:WatchdogThread]
+        my_logger level: 'info', msg: "CloseSocket: Socket Closed & Threads Killed"
+      rescue
+        my_logger level: 'error', msg:  "CloseSocket Rescue: #$!"
       end
+      my_logger  msg:  "Exiting CloseSocket"
+    end
   end
 
+
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
     # Proceses json object returned by gpsd daemon. The TPV and SKY object
     # are used the most as they give info about satellites used and gps locations
     # @param [JSON] json The object returned by the daemon
@@ -255,7 +339,7 @@ class MyGpsdClient
                #we have a 2d or 3d fix
                 if is_new_measurement(json: json)
                     json['time'] = DateTime.parse(json['time'])
-                    puts "lat: #{json['lat']}, lng: #{json['lon']}, alt: #{json['alt']}, speed: #{json['speed']} at #{json['time']}, which is #{(Time.now - json['time'].to_time) * 1000}ms old" if @verbose
+                    my_logger  level: 'info', msg:  "lat: #{json['lat']}, lng: #{json['lon']}, alt: #{json['alt']}, speed: #{json['speed']} at #{json['time']}, which is #{(Time.now - json['time'].to_time) * 1000}ms old"
                     @json_pos_callback.call(json) if @json_pos_callback
                 end
             end
@@ -264,16 +348,16 @@ class MyGpsdClient
             @msg_counts[:sky] += 1
             sats = json['satellites']
             if satellites_changed(sats: sats)
-                puts "found #{sats.length} satellites, of which #{sats.count{|sat| sat['used']}} are used" if @verbose
+                my_logger  level: 'info', msg:  "found #{sats.length} satellites, of which #{sats.count{|sat| sat['used']}} are used"
                 @json_sat_callback.call(sats) if @json_sat_callback
             end
         when 'PPS'
           @msg_counts[:pps] += 1
-          puts "found PPS tag: #{json.inspect}" if @verbose
+          my_logger  level: 'info', msg:  "found PPS tag: #{json.inspect}"
           @json_pps_callback.call(json) if @json_pps_callback
         else
           @msg_counts[:unk] += 1
-          puts "found unknown tag: #{json.inspect}" if @verbose
+          my_logger level: 'info', msg:  "found unknown tag: #{json.inspect}"
           @json_unk_callback.call(json) if @json_unk_callback
         end
         @json_raw_callback.call(json) if @json_raw_callback
@@ -299,19 +383,73 @@ class MyGpsdClient
       return false
   end
 
-  # Close the gps deamon socket
-  def close_socket
-    begin
-      if @socket
-        msg = '?WATCH={"enable":false}'
-        @sent_raw_callback.call( msg) if @sent_raw_callback
-        @socket.puts msg
-        @socket.close
-      end
-      @socket = nil
-    rescue
-      puts "#$!" if @verbose
-    end
+  # @return [string] status info string containing nr satellites, fix, speed
+  def to_status
+      return "lat: #{last['lat']}, lng: #{last['lon']}, speed:#{last['speed']}, sats: #{@sats.length}(#{@sats.count{|sat| sat['used']}})" if @socket_ready and @last and @sats
+      return "lat: #{last['lat']}, lng: #{last['lon']}, speed:#{last['speed']}" if @socket_ready and @last and @sats.nil?
+      return "sats: #{@sats.length}(#{@sats.count{|sat| sat['used']}}), no fix yet" if @socket_ready and @last.nil? and @sats
+      return "connected with gpsd, waiting for data" if @socket_ready
+      return "waiting for connection with gpsd" if @socket_ready == false
+  end
+
+  def on_raw_send(options:{}, &block)
+    @sent_raw_callback = block
+  end
+
+  # @param [Object] options Possible options to pass (not used yet)
+  # @param [Block] block Block to call when new json object comes from gpsd
+  def on_raw_change(options:{}, &block)
+      @json_raw_callback = block
+  end
+
+  # @param [Object] options Possible options to pass (not used yet)
+  # @param [Block] block Block to call when new gps position json object comes from gpsd
+  def on_position_change(options:{}, &block)
+      @json_pos_callback = block
+  end
+
+  # @param [Object] options Possible options to pass (not used yet)
+  # @param [Block] block Block to call when new satellite info json object comes from gpsd
+  def on_satellites_change(options:{}, &block)
+      @json_sat_callback = block
+  end
+
+  # @param [Object] options Possible options to pass (not used yet)
+  # @param [Block] block Block to call when new pps info json object comes from gpsd
+  def on_pps_change(options:{}, &block)
+      @json_pps_callback = block
+  end
+
+  # @param [Object] options Possible options to pass (not used yet)
+  # @param [Block] block Block to call when new pps info json object comes from gpsd
+  def on_unk_change(options:{}, &block)
+      @json_unk_callback = block
+  end
+
+  def reset_msg_counts
+    @msg_counts.each_key { |k| @msg_counts[k] = 0 }
+  end
+
+  def self.version
+    MyGpsdClient_version::VERSION
+  end
+
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  #~~~~~~~~~~~~~~~~~~~~~ SETUP LOGGING ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+  #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+LOG_LEVELS = {debug: Logger::DEBUG, info: Logger::INFO, warn: Logger::WARN,
+      error: Logger::ERROR, fatal: Logger::FATAL, unknown: Logger::UNKNOWN}
+
+  def my_logger(level: 'debug', msg: "Blank")
+    MyGpsdClient.logger.add (LOG_LEVELS[level.to_sym]) {"#{Thread.current[:name]} -- #{msg}"}
+  end
+
+  def self.logger
+    @@logger ||= defined?(Rails) ? Rails.logger : Logger.new("log/MyGpsdClient.log")
+  end
+
+  def self.logger=(logger)
+    @@logger = logger
   end
 
 

data/lib/my_gpsd_client/version.rb

@@ -1,3 +1,3 @@
 class MyGpsdClient_version
-  VERSION = "0.1.30"
+  VERSION = "0.02.00"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: my_gpsd_client
 version: !ruby/object:Gem::Version
-  version: 0.1.30
+  version: 0.02.00
 platform: ruby
 authors:
 - Steven Finnegan
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-10-11 00:00:00.000000000 Z
+date: 2019-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler