my_gpsd_client 0.1.30

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ee600b4280ec136fb4493892c58b4bb008e33c1f8224ce20bbf1991ea534e469
+  data.tar.gz: 2b760c07a8cb3e090f2b4a2d53f11edbc3811425004e093e902913fdceeaba52
+SHA512:
+  metadata.gz: 9596d2cd259de9f857a47124e0b171be2a3378cc73b47de6b22e00eee3bea431caf15af18e97d4ace0864808c0c73325604887e3426ca5315d1400dc2efac105
+  data.tar.gz: 731aea1ff46f96c1c60909c4cf41c02c45772b5bf458f7177129df18fc6ca17cb220a318d2fc9de3f8a7cc24fd019ea75427e211ebc3da16beca8d922244300f

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Deploy.md

@@ -0,0 +1,4 @@
+Procedure to build gem and push to rubygem.org
+1. Verify **lib/my_gpsd_client/version.rb** contains an updated version
+2. gem build my_gpsd_client.gemspec
+3. gem push my_gpsd_client-x.x.xx.gem

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in my_gpsd_client.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    my_gpsd_client (0.1.25)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.17)
+  my_gpsd_client!
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.17.3

data/README.md

@@ -0,0 +1,59 @@
+# MyGpsdClient
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/my_gpsd_client`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'my_gpsd_client'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install my_gpsd_client
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+
+## To build, load and run a gem (from my notes)
+
+From the gem's main folder...
+
+    $ gem build my_gpsd_client.gemspec
+    $ gem install my_gpsd_client-0.1.10.gem
+
+    $ irb
+    irb(main):001:0> require 'my_gpsd_client'
+    => true
+    irb(main):002:0> gps = MyGpsdClient.new()
+    => #<MyGpsdClient:0x00007fd8b98806a0...
+    irb(main):003:0> gps.version
+    => "0.1.17"
+    irb(main):004:0> 
+
+To release to rubygems.org...
+
+    $ rake build
+    my_gpsd_client 0.1.10 built to pkg/my_gpsd_client-0.1.0.gem.
+
+    $ rake release
+    my_gpsd_client 0.1.10 built to pkg/my_gpsd_client-0.1.0.gem.
+    Tagged v0.1.10.
+    Pushed git commits and tags.
+    Pushed my_gpsd_client 0.1.10 to https://rubygems.org

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "my_gpsd_client"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/my_gpsd_client/version.rb

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

data/lib/my_gpsd_client.rb

@@ -0,0 +1,318 @@
+require "my_gpsd_client/version"
+require 'socket'
+require 'json'
+require 'date'
+
+class MyGpsdClient
+  attr_accessor :host, :port, :watch, :verbose, :min_speed, :watchdog_max, :watchdog_force
+  attr_reader :version, :socket_ready, :msg_counts, :watchdog_fired_count
+
+  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.
+  # @example Easy setup
+  # gps = GPSD2JSON.new()
+  # gps.on_satellites_change { |sats| STDERR.puts "found #{sats.length} satellites, of which #{sats.count{|sat| sat['used']} } active" }
+  # gps.on_position_change { |pos| STDERR.puts "lat: #{pos['lat']}, lng: #{pos['lon']}, alt: #{pos['alt']}, speed: #{pos['speed']} at #{pos['time']}, which is #{(Time.now - pos['time'].to_time) * 1000}ms old" }
+  # gps.start
+  # #when done
+  # gps.stop
+  # @example Quickest raw mode, just dumping all json packets as the are
+  # gps = GPSD2JSON.new()
+  # gps.on_raw_change { |raw| STDERR.puts raw.inspect }
+  # gps.start
+  # #when done
+  # gps.stop
+  def initialize(host: 'localhost', port: 2947, watch: DEFAULT_WATCH, verbose: false)
+    @version = MyGpsdClient_version::VERSION
+    @verbose = verbose
+    @socket = nil
+    @socket_ready = false
+    @host = host
+    @port = port
+    @watch = watch
+    @trackthread = nil
+    @socket_init_thread = nil
+    @watchdog_thread = nil
+    @watchdog_count = 0
+    @watchdog_max = 10
+    @watchdog_fired_count = 0
+    @watchdog_force = false
+    @min_speed = 0 # speed needs to be higher than this to make the gps info count
+    @last = nil #last gps info
+    @sats = nil # last satellites info
+    @sent_raw_callback = nil
+    @json_raw_callback = nil
+    @json_pos_callback = nil
+    @json_sat_callback = nil
+    @json_pps_callback = nil
+    @json_unk_callback = nil
+    @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
+  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
+
+
+  # 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
+
+          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
+      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
+      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
+            stop
+            sleep 1
+            start
+          end
+          sleep 1
+        end
+      end
+
+  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
+
+  # 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
+      @socket_ready = false
+      Thread.kill(@socket_init_thread) if @socket_init_thread
+      Thread.kill(@trackthread) if @trackthread
+    end
+
+  # initialize gpsd socket
+  def init_socket
+      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
+      rescue
+          @socket_ready = false
+          puts "#$!" if @verbose
+      end
+  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
+      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
+    def parse_socket_json(json:)
+        case json['class']
+        when 'TOFF'
+          @msg_counts[:toff] += 1
+        when 'ATT'
+          @msg_counts[:att] += 1
+        when 'ERR'
+          @msg_counts[:err] += 1
+        when 'GST'
+          @msg_counts[:gst] += 1
+        when 'POL'
+          @msg_counts[:pol] += 1
+        when 'DEVICE'
+          @msg_counts[:dev] += 1
+        when 'DEVICES'
+            # devices that are found, not needed
+            @msg_counts[:devs] += 1
+        when 'WATCH'
+            # gps deamon is ready and will send other packets, not needed yet
+            @msg_counts[:wtch] += 1
+        when 'TPV'
+            # gps position
+            #  "tag"=>"RMC", #  "device"=>"/dev/ttyS0", #  "mode"=>3,
+            #  "time"=>"2017-11-28T12:54:54.000Z", #  "ept"=>0.005, #  "lat"=>52.368576667,
+            #  "lon"=>4.901715, #  "alt"=>-6.2, #  "epx"=>2.738, #  "epy"=>3.5,
+            #  "epv"=>5.06, #  "track"=>198.53, #  "speed"=>0.19, #  "climb"=>0.0,
+            #  "eps"=>7.0, #  "epc"=>10.12
+            @msg_counts[:tpv] += 1
+            if json['mode'] > 1
+               #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
+                    @json_pos_callback.call(json) if @json_pos_callback
+                end
+            end
+        when 'SKY'
+            # report on found satellites
+            @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
+                @json_sat_callback.call(sats) if @json_sat_callback
+            end
+        when 'PPS'
+          @msg_counts[:pps] += 1
+          puts "found PPS tag: #{json.inspect}" if @verbose
+          @json_pps_callback.call(json) if @json_pps_callback
+        else
+          @msg_counts[:unk] += 1
+          puts "found unknown tag: #{json.inspect}" if @verbose
+          @json_unk_callback.call(json) if @json_unk_callback
+        end
+        @json_raw_callback.call(json) if @json_raw_callback
+    end
+
+  # checks if the new satellites object return by the deamon is different enough compared
+  # to the last one, to use it
+  def satellites_changed(sats:)
+      if @sats.nil? or (@sats.length != sats.length or @sats.count{|sat| sat['used']} != sats.count{|sat| sat['used']})
+          @sats = sats
+          return true
+      end
+      return false
+  end
+
+  # checks if the new location object return by the deamon is different enough compared
+  # to the last one, to use it. it could be disregarded for example because the speed is to low, and you don't want to have the location jumping around when you stand still
+  def is_new_measurement(json:)
+      if @last.nil? or (@last['lat'] != json['lat'] and @last['lon'] != json['lon'] and json['speed'] >= @min_speed)
+          @last = json
+          return true
+      end
+      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
+  end
+
+
+end

data/my_gpsd_client.gemspec

@@ -0,0 +1,41 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "my_gpsd_client/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "my_gpsd_client"
+  spec.version       = MyGpsdClient_version::VERSION
+  spec.authors       = ["Steven Finnegan"]
+  spec.email         = ["steven@rustyshamrock.com"]
+
+  spec.summary       = %q{My version of gpsd2json gem}
+#  spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.homepage      = "https://github.com/sjf-control/my_gpsd_client"
+  spec.license      = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = 'https://rubygems.org'
+
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = 'https://github.com/sjf-control/my_gpsd_client'
+  #  spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: my_gpsd_client
+version: !ruby/object:Gem::Version
+  version: 0.1.30
+platform: ruby
+authors:
+- Steven Finnegan
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-10-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- steven@rustyshamrock.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Deploy.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/my_gpsd_client.rb
+- lib/my_gpsd_client/version.rb
+- my_gpsd_client.gemspec
+homepage: https://github.com/sjf-control/my_gpsd_client
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/sjf-control/my_gpsd_client
+  source_code_uri: https://github.com/sjf-control/my_gpsd_client
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: My version of gpsd2json gem
+test_files: []