myhidapi 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: adfdddd71f381dfa83086b83af2a81dc686adf21df076b0286e253eb002491e1
+  data.tar.gz: 712d3badf64f7fdae9d6e6fbb8ebfda805f1668d83539a5ac6761d9a39b9198d
+SHA512:
+  metadata.gz: 8a965240dbb7b7a760626bf7827beded3544c13629c021cb5980674ebecea5255a8734e22093aafded0fdfcf46c17b0e8c3a2f345262d18590a74564c9c523d4
+  data.tar.gz: 10d73dd3d377bc809e6d670de618dfa22459197ddf076630f3732a6d3815ad66bccd6cdbcafb3509b7b73f320d8a3e7580edd6052ab3b2f2265cdb38f83fc461

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2019-02-15
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,10 @@
+CHANGELOG.md
+Manifest.txt
+README.md
+Rakefile
+ext/myhidapi/extconf.rb
+ext/myhidapi/myhidapi.c
+lib/myhidapi.rb
+sample/kbprog.rb
+sample/set_hsv.rb
+test/test_myhidapi.rb

data/README.md

@@ -0,0 +1,73 @@
+# MyHIDAPI
+
+* https://github.com/tenderlove/myhidapi
+
+## DESCRIPTION:
+
+This is a small wrapper around HIDAPI.  I couldn't get other HIDAPI wrappers to
+work, so I wrote this one.  I'm using it to communicate with my keyboard, so
+it really only supports enough of the HIDAPI to do that.
+
+## FEATURES/PROBLEMS:
+
+* Incomplete
+* No tests
+* Seems to work (for me)
+
+## SYNOPSIS:
+
+```ruby
+ devices = MyHIDAPI.enumerate 0x0, 0x0
+ dev = devices.find { |dev| dev.product_string == "ErgoDox EZ" }
+
+ handle = dev.open
+
+ while !handle
+   p "retry"
+   handle = dev.open
+ end
+
+ p handle
+
+ buf = [0x0, 0x3, 35]
+ loop do
+   break if handle.write buf.pack('C*')
+ end
+ puts "done writing"
+
+ buf = handle.read_timeout 1, 500
+ p buf
+ ```
+
+## REQUIREMENTS:
+
+This depends on libhidapi.
+
+## INSTALL:
+
+* Install hidapi.  On MacOS that is `brew install hidapi`
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2019 Aaron Patterson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,41 @@
+# -*- ruby -*-
+
+require 'rubygems'
+
+tries = 0
+begin
+  require 'hoe'
+  require 'minitest'
+  require 'rake/extensiontask'
+rescue LoadError
+  tries += 1
+  Gem.install 'hoe'
+  Gem.install 'rake-compiler'
+  Gem.install 'hoe-gemspec'
+  Gem.install 'hoe-git'
+  Gem.install 'minitest'
+  raise unless tries < 10
+  retry
+end
+
+Hoe.plugin :minitest
+Hoe.plugin :gemspec # `gem install hoe-gemspec`
+Hoe.plugin :git     # `gem install hoe-git`
+
+HOE = Hoe.spec 'myhidapi' do
+  developer('Aaron Patterson', 'tenderlove@ruby-lang.org')
+  license "MIT"
+  self.readme_file   = 'README.md'
+  self.history_file  = 'CHANGELOG.md'
+  self.extra_rdoc_files  = FileList['*.md']
+
+  self.spec_extras = {
+    :extensions => ["ext/myhidapi/extconf.rb"],
+    :required_ruby_version => '>= 2.3.0'
+  }
+end
+
+Rake::ExtensionTask.new("myhidapi", HOE.spec) do |ext|
+end
+
+# vim: syntax=ruby

data/ext/myhidapi/extconf.rb

@@ -0,0 +1,25 @@
+require 'mkmf'
+
+ldflags = cppflags = nil
+if RbConfig::CONFIG["host_os"] =~ /darwin/
+  begin
+    brew_prefix = `brew --prefix hidapi`.chomp
+    ldflags   = "#{brew_prefix}/lib"
+    cppflags  = "#{brew_prefix}/include"
+    pkg_conf  = "#{brew_prefix}/lib/pkgconfig"
+
+    # pkg_config should be less error prone than parsing compiler
+    # commandline options, but we need to set default ldflags and cpp flags
+    # in case the user doesn't have pkg-config installed
+    ENV['PKG_CONFIG_PATH'] ||= pkg_conf
+  rescue
+  end
+end
+
+pkg_config 'hidapi'
+
+dir_config("hidapi", cppflags, ldflags)
+
+raise "Install hidapi (brew install hidapi)" unless have_header 'hidapi.h'
+
+create_makefile 'myhidapi'

data/ext/myhidapi/myhidapi.c

@@ -0,0 +1,178 @@
+#include <ruby.h>
+#include <hidapi.h>
+#include <stdlib.h>
+
+VALUE mMyHIDAPI;
+VALUE cMyHIDAPIHandle;
+
+static void dealloc(void * ptr)
+{
+    hid_device *handle = (hid_device *)ptr;
+    hid_close(handle);
+}
+
+static const rb_data_type_t myhidapi_handle_type = {
+    "MyHIDAPI/Handle",
+    {0, dealloc, 0,},
+    0, 0,
+#ifdef RUBY_TYPED_FREE_IMMEDIATELY
+    RUBY_TYPED_FREE_IMMEDIATELY,
+#endif
+};
+
+#define BUF_SIZE 4096
+
+static VALUE
+rb_wcstombs(wchar_t *str)
+{
+    char buf[BUF_SIZE];
+    int len;
+    len = wcstombs(buf, str, BUF_SIZE);
+    if (len > 0) {
+	return rb_str_new(buf, len);
+    } else {
+	return Qnil;
+    }
+}
+
+static VALUE
+enumerate(VALUE mod, VALUE vendor_id, VALUE product_id)
+{
+    VALUE devices;
+    struct hid_device_info *devs, *cur_dev;
+
+    devices = rb_ary_new();
+    devs = hid_enumerate(NUM2USHORT(vendor_id), NUM2USHORT(product_id));
+    cur_dev = devs;
+    while (cur_dev) {
+	rb_ary_push(devices, rb_funcall(mMyHIDAPI, rb_intern("build_device_info"), 8,
+		INT2NUM(cur_dev->vendor_id),
+		INT2NUM(cur_dev->product_id),
+		rb_str_new2(cur_dev->path),
+		rb_wcstombs(cur_dev->serial_number),
+		rb_wcstombs(cur_dev->manufacturer_string),
+		rb_wcstombs(cur_dev->product_string),
+		INT2NUM(cur_dev->usage),
+		INT2NUM(cur_dev->interface_number)
+		));
+	cur_dev = cur_dev->next;
+    }
+    hid_free_enumeration(devs);
+
+    return devices;
+}
+
+static VALUE
+rb_hid_open(VALUE mod, VALUE vid, VALUE pid)
+{
+    hid_device *handle;
+
+    handle = hid_open(NUM2USHORT(vid), NUM2USHORT(pid), NULL);
+
+    if (handle) {
+	return TypedData_Wrap_Struct(cMyHIDAPIHandle, &myhidapi_handle_type, handle);
+    } else {
+	return Qfalse;
+    }
+}
+
+static VALUE
+rb_hid_open_path(VALUE mod, VALUE path)
+{
+    hid_device *handle;
+
+    handle = hid_open_path(StringValueCStr(path));
+
+    if (handle) {
+	return TypedData_Wrap_Struct(cMyHIDAPIHandle, &myhidapi_handle_type, handle);
+    } else {
+	return Qfalse;
+    }
+}
+
+static VALUE
+rb_hid_write(VALUE self, VALUE str)
+{
+    hid_device *handle;
+    int written;
+
+    TypedData_Get_Struct(self, hid_device, &myhidapi_handle_type, handle);
+
+    written = hid_write(handle, (unsigned char *)StringValuePtr(str), RSTRING_LEN(str));
+
+    if (written >= 0) {
+	return INT2NUM(written);
+    } else {
+	return Qfalse;
+    }
+}
+
+static VALUE
+rb_hid_set_nonblocking(VALUE self, VALUE val)
+{
+    hid_device *handle;
+    TypedData_Get_Struct(self, hid_device, &myhidapi_handle_type, handle);
+    if (!hid_set_nonblocking(handle, NUM2INT(val))) {
+	return Qtrue;
+    } else {
+	return Qnil;
+    }
+}
+
+static VALUE
+rb_hid_read(VALUE self, VALUE size)
+{
+    hid_device *handle;
+    unsigned char * buf;
+    int read;
+    VALUE ret;
+
+    TypedData_Get_Struct(self, hid_device, &myhidapi_handle_type, handle);
+
+    buf = xcalloc(NUM2SIZET(size), sizeof(unsigned char));
+
+    read = hid_read(handle, buf, NUM2SIZET(size));
+
+    if (read > 0) {
+	ret = rb_str_new((char *)buf, read);
+    } else {
+	ret = Qnil;
+    }
+    xfree(buf);
+    return ret;
+}
+
+static VALUE
+rb_hid_read_timeout(VALUE self, VALUE size, VALUE timeout_ms)
+{
+    hid_device *handle;
+    unsigned char * buf;
+    int read;
+    VALUE ret;
+
+    TypedData_Get_Struct(self, hid_device, &myhidapi_handle_type, handle);
+
+    buf = xcalloc(NUM2SIZET(size), sizeof(unsigned char));
+
+    read = hid_read_timeout(handle, buf, NUM2SIZET(size), NUM2INT(timeout_ms));
+
+    if (read > 0) {
+	ret = rb_str_new((char *)buf, read);
+    } else {
+	ret = Qnil;
+    }
+    xfree(buf);
+    return ret;
+}
+
+void Init_myhidapi() {
+    mMyHIDAPI = rb_define_module("MyHIDAPI");
+    cMyHIDAPIHandle = rb_define_class_under(mMyHIDAPI, "Handle", rb_cObject);
+    rb_define_singleton_method(mMyHIDAPI, "enumerate", enumerate, 2);
+    rb_define_singleton_method(mMyHIDAPI, "open", rb_hid_open, 2);
+    rb_define_singleton_method(mMyHIDAPI, "open_path", rb_hid_open_path, 1);
+    rb_define_method(cMyHIDAPIHandle, "write", rb_hid_write, 1);
+    rb_define_method(cMyHIDAPIHandle, "read", rb_hid_read, 1);
+    rb_define_method(cMyHIDAPIHandle, "read_timeout", rb_hid_read_timeout, 2);
+    rb_define_method(cMyHIDAPIHandle, "set_nonblocking", rb_hid_set_nonblocking, 1);
+}

data/lib/myhidapi.rb

@@ -0,0 +1,28 @@
+require "myhidapi.so"
+
+module MyHIDAPI
+  VERSION = '1.0.0'
+
+  class DeviceInfo
+    attr_reader :vendor_id, :product_id, :path, :serial_number, :manufacturer_string, :product_string, :usage, :interface_number
+
+    def initialize vendor_id, product_id, path, serial_number, manufacturer_string, product_string, usage, interface_number
+      @vendor_id           = vendor_id
+      @product_id          = product_id
+      @path                = path
+      @serial_number       = serial_number
+      @manufacturer_string = manufacturer_string
+      @product_string      = product_string
+      @usage               = usage
+      @interface_number    = interface_number
+    end
+
+    def open
+      MyHIDAPI.open vendor_id, product_id
+    end
+  end
+
+  def self.build_device_info(*args)
+    DeviceInfo.new(*args)
+  end
+end

data/sample/kbprog.rb

@@ -0,0 +1,190 @@
+require 'myhidapi'
+require 'optparse'
+
+class TeeloKB
+  class Error < StandardError; end
+  class CouldNotReadError < Error; end
+  class KeyboardNotFoundError < Error; end
+
+  COMMAND_VERSIONS = { 1 => {} }
+
+  %i{
+    version
+    rgblight_enable
+    rgblight_disable
+    rgblight_toggle
+    rgblight_mode
+    rgblight_sethsv
+    rgblight_get_mode
+    rgblight_get_hue
+    rgblight_get_sat
+    rgblight_get_val
+  }.each_with_index do |command, index|
+    COMMAND_VERSIONS[1][command] = index + 1
+  end
+
+  def self.find
+    MyHIDAPI.enumerate(0x0, 0x0).find { |dev| dev.product_string == "ErgoDox EZ" }
+  end
+
+  def self.open
+    dev = self.find
+
+    retries = 0
+    handle = dev.open
+    while !handle
+      retries += 1
+      raise KeyboardNotFoundError, "Couldn't find keyboard" if retries > 10
+      handle = dev.open
+    end
+
+    new handle
+  end
+
+  def initialize handle
+    @handle = handle
+    @version = protocol_version
+  end
+
+  def protocol_version
+    write [0x0, 0x1]
+    read(2).inject(:+)
+  end
+
+  def solid
+    rgblight_mode 0x1
+  end
+
+  def enable
+    write [0x0, _(:rgblight_enable)]
+    read 10
+  end
+
+  def disable
+    write [0x0, _(:rgblight_disable)]
+    read 10
+  end
+
+  def toggle
+    write [0x0, _(:rgblight_toggle)]
+    read 10
+  end
+
+  def mode
+    write [0x0, _(:rgblight_get_mode)]
+    read(2).last
+  end
+
+  def rainbow style = 0x6
+    rgblight_mode style
+  end
+
+  def rgblight_mode value
+    write [0x0, _(:rgblight_mode), value & 0xFF]
+    read 10
+  end
+  alias :mode= :rgblight_mode
+
+  def rgblight_sethsv h, s, v
+    write([0x0, _(:rgblight_sethsv)] + [(h >> 8) & 0xFF, h & 0xFF, s & 0xFF, v & 0xFF])
+    read 10
+  end
+  alias :sethsv :rgblight_sethsv
+
+  def setrgb r, g, b
+    sethsv *rgb2hsv(r, g, b)
+  end
+
+  def hue
+    write [0x0, _(:rgblight_get_hue)]
+    _, upper, lower = read 3
+    (upper << 8) | lower
+  end
+
+  def saturation
+    write [0x0, _(:rgblight_get_sat)]
+    read(2)[1]
+  end
+
+  def value
+    write [0x0, _(:rgblight_get_val)]
+    read(2)[1]
+  end
+
+  def hsv
+    [hue, saturation, value]
+  end
+
+  private
+
+  def rgb2hsv r, g, b
+    v     = [r, g, b].max
+    delta = v - [r, g, b].min
+
+    s = v == 0 ? 0 : (delta / v.to_f)
+    h = delta == 0 ? 0 : (case v
+    when r then ((g - b) / delta) % 6
+    when g then ((b - r) / delta) + 2
+    when b then ((r - g) / delta) + 4
+    end) * 60
+
+    [h.round, (s * 255).round, v]
+  end
+
+  def write buf
+    loop do
+      break if @handle.write buf.pack('C*')
+    end
+  end
+
+  def read size
+    buf = @handle.read_timeout size, 300 # 300 ms timeout
+    if buf
+      buf.unpack('C*')
+    else
+      # Unfortunately, this seems to happen frequently.
+      raise CouldNotReadError, "could not read from device"
+    end
+  end
+
+  def _ command
+    COMMAND_VERSIONS.fetch(@version).fetch(command)
+  end
+end
+
+commands = []
+responses = []
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: kbprog.rb [options]"
+
+  opts.on("--hsv=[HSV]", "Set or get HSV (comma separated)") do |v|
+    if v
+      commands << lambda { |kb| kb.sethsv(*v.split(",").map(&:to_i)) }
+    else
+      commands << lambda { |kb| responses << { hsv: kb.hsv } }
+    end
+  end
+  opts.on("--mode=[HSV]", "Set or get mode") do |v|
+    if v
+      commands << lambda { |kb| kb.mode = v.to_i }
+    else
+      commands << lambda { |kb| responses << { mode: kb.mode } }
+    end
+  end
+end.parse!
+
+kb = TeeloKB.open
+commands.each { |cmd| cmd.call kb }
+responses.each do |res|
+  p res
+end
+
+#p ez.mode
+#ez.mode = 5
+#ez.sethsv 300, 250, 255
+#p ez.hsv
+
+#rescue TeeloKB::Error => e
+#  exec "ruby --disable-gems -I lib:test #{__FILE__}"
+#end

data/sample/set_hsv.rb

@@ -0,0 +1,21 @@
+require 'myhidapi'
+
+def try_block times
+  times.times { x = yield; return x if x }
+  raise "Couldn't do it"
+end
+
+dev = MyHIDAPI.enumerate(0x0, 0x0).find { |dev| dev.product_string == "ErgoDox EZ" }
+
+handle = try_block(10) { dev.open }
+p handle
+
+h = 0    # 0x0 to 0x168 (which is 360 base 10)
+s = 0xFF # 0x0 to 0xFF
+v = 0xFF # 0x0 to 0xFF
+
+try_block(10) do
+  handle.write [0x0, 0x6, (h >> 8) & 0xFF, h & 0xFF, s, v].pack('C*')
+end
+
+handle.read_timeout 10, 300 # 300 ms timeout

data/test/test_myhidapi.rb

@@ -0,0 +1,33 @@
+require 'minitest/autorun'
+require 'myhidapi'
+
+class TestMyHIDAPI < MiniTest::Test
+  def test_it_works
+    devices = MyHIDAPI.enumerate 0x0, 0x0
+    dev = devices.find { |dev| dev.product_string == "ErgoDox EZ" }
+
+    handle = dev.open
+
+    while !handle
+      p "retry"
+      handle = dev.open
+    end
+
+    p handle
+
+    buf = [0x0, 0x3, 35]
+    loop do
+      break if handle.write buf.pack('C*')
+    end
+    puts "done writing"
+
+    buf = handle.read_timeout 1, 500
+    p buf
+  end
+
+  def test_can_enumerate_by_ids
+    devices = MyHIDAPI.enumerate(0xfeed, 0x1307)
+
+    refute_predicate devices, :empty?
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: myhidapi
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aaron Patterson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.17'
+description: |-
+  This is a small wrapper around HIDAPI.  I couldn't get other HIDAPI wrappers to
+  work, so I wrote this one.  I'm using it to communicate with my keyboard, so
+  it really only supports enough of the HIDAPI to do that.
+email:
+- tenderlove@ruby-lang.org
+executables: []
+extensions:
+- ext/myhidapi/extconf.rb
+extra_rdoc_files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+files:
+- CHANGELOG.md
+- Manifest.txt
+- README.md
+- Rakefile
+- ext/myhidapi/extconf.rb
+- ext/myhidapi/myhidapi.c
+- lib/myhidapi.rb
+- sample/kbprog.rb
+- sample/set_hsv.rb
+- test/test_myhidapi.rb
+homepage: https://github.com/tenderlove/myhidapi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: This is a small wrapper around HIDAPI
+test_files: []