rawhid 0.1.1

data/ext/rawhid/hid_WINDOWS.c

@@ -0,0 +1,328 @@
+/* Simple Raw HID functions for Windows - for use with Teensy RawHID example
+ * http://www.pjrc.com/teensy/rawhid.html
+ * Copyright (c) 2009 PJRC.COM, LLC
+ *
+ *  rawhid_open - open 1 or more devices
+ *  rawhid_recv - receive a packet
+ *  rawhid_send - send a packet
+ *  rawhid_close - close a device
+ *
+ * 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 description, website URL and 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.
+ *
+ * Version 1.0: Initial Release
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <windows.h>
+#include <setupapi.h>
+#include <ddk/hidsdi.h>
+#include <ddk/hidclass.h>
+
+#include "hid.h"
+
+
+// a list of all opened HID devices, so the caller can
+// simply refer to them by number
+typedef struct hid_struct hid_t;
+static hid_t *first_hid = NULL;
+static hid_t *last_hid = NULL;
+struct hid_struct {
+	HANDLE handle;
+	int open;
+	struct hid_struct *prev;
+	struct hid_struct *next;
+};
+static HANDLE rx_event=NULL;
+static HANDLE tx_event=NULL;
+static CRITICAL_SECTION rx_mutex;
+static CRITICAL_SECTION tx_mutex;
+
+
+// private functions, not intended to be used from outside this file
+static void add_hid(hid_t *h);
+static hid_t * get_hid(int num);
+static void free_all_hid(void);
+static void hid_close(hid_t *hid);
+void print_win32_err(void);
+
+
+
+
+//  rawhid_recv - receive a packet
+//    Inputs:
+//	num = device to receive from (zero based)
+//	buf = buffer to receive packet
+//	len = buffer's size
+//	timeout = time to wait, in milliseconds
+//    Output:
+//	number of bytes received, or -1 on error
+//
+int rawhid_recv(int num, void *buf, int len, int timeout)
+{
+	hid_t *hid;
+	unsigned char tmpbuf[516];
+	OVERLAPPED ov;
+	DWORD n, r;
+
+	if (sizeof(tmpbuf) < len + 1) return -1;
+	hid = get_hid(num);
+	if (!hid || !hid->open) return -1;
+	EnterCriticalSection(&rx_mutex);
+	ResetEvent(&rx_event);
+	memset(&ov, 0, sizeof(ov));
+	ov.hEvent = rx_event;
+	if (!ReadFile(hid->handle, tmpbuf, len + 1, NULL, &ov)) {
+		if (GetLastError() != ERROR_IO_PENDING) goto return_error;
+		r = WaitForSingleObject(rx_event, timeout);
+		if (r == WAIT_TIMEOUT) goto return_timeout;
+		if (r != WAIT_OBJECT_0) goto return_error;
+	}
+	if (!GetOverlappedResult(hid->handle, &ov, &n, FALSE)) goto return_error;
+	LeaveCriticalSection(&rx_mutex);
+	if (n <= 0) return -1;
+	n--;
+	if (n > len) n = len;
+	memcpy(buf, tmpbuf + 1, n);
+	return n;
+return_timeout:
+	CancelIo(hid->handle);
+	LeaveCriticalSection(&rx_mutex);
+	return 0;
+return_error:
+	print_win32_err();
+	LeaveCriticalSection(&rx_mutex);
+	return -1;
+}
+
+//  rawhid_send - send a packet
+//    Inputs:
+//	num = device to transmit to (zero based)
+//	buf = buffer containing packet to send
+//	len = number of bytes to transmit
+//	timeout = time to wait, in milliseconds
+//    Output:
+//	number of bytes sent, or -1 on error
+//
+int rawhid_send(int num, void *buf, int len, int timeout)
+{
+	hid_t *hid;
+	unsigned char tmpbuf[516];
+	OVERLAPPED ov;
+	DWORD n, r;
+
+	if (sizeof(tmpbuf) < len + 1) return -1;
+	hid = get_hid(num);
+	if (!hid || !hid->open) return -1;
+	EnterCriticalSection(&tx_mutex);
+	ResetEvent(&tx_event);
+	memset(&ov, 0, sizeof(ov));
+	ov.hEvent = tx_event;
+	tmpbuf[0] = 0;
+	memcpy(tmpbuf + 1, buf, len);
+	if (!WriteFile(hid->handle, tmpbuf, len + 1, NULL, &ov)) {
+		if (GetLastError() != ERROR_IO_PENDING) goto return_error;
+		r = WaitForSingleObject(tx_event, timeout);
+		if (r == WAIT_TIMEOUT) goto return_timeout;
+		if (r != WAIT_OBJECT_0) goto return_error;
+	}
+	if (!GetOverlappedResult(hid->handle, &ov, &n, FALSE)) goto return_error;
+	LeaveCriticalSection(&tx_mutex);
+	if (n <= 0) return -1;
+	return n - 1;
+return_timeout:
+	CancelIo(hid->handle);
+	LeaveCriticalSection(&tx_mutex);
+	return 0;
+return_error:
+	print_win32_err();
+	LeaveCriticalSection(&tx_mutex);
+	return -1;
+}
+
+//  rawhid_open - open 1 or more devices
+//
+//    Inputs:
+//	max = maximum number of devices to open
+//	vid = Vendor ID, or -1 if any
+//	pid = Product ID, or -1 if any
+//	usage_page = top level usage page, or -1 if any
+//	usage = top level usage number, or -1 if any
+//    Output:
+//	actual number of devices opened
+//
+int rawhid_open(int max, int vid, int pid, int usage_page, int usage)
+{
+        GUID guid;
+        HDEVINFO info;
+        DWORD index=0, reqd_size;
+        SP_DEVICE_INTERFACE_DATA iface;
+        SP_DEVICE_INTERFACE_DETAIL_DATA *details;
+        HIDD_ATTRIBUTES attrib;
+        PHIDP_PREPARSED_DATA hid_data;
+        HIDP_CAPS capabilities;
+        HANDLE h;
+        BOOL ret;
+	hid_t *hid;
+	int count=0;
+
+	if (first_hid) free_all_hid();
+	if (max < 1) return 0;
+	if (!rx_event) {
+		rx_event = CreateEvent(NULL, TRUE, TRUE, NULL);
+		tx_event = CreateEvent(NULL, TRUE, TRUE, NULL);
+		InitializeCriticalSection(&rx_mutex);
+		InitializeCriticalSection(&tx_mutex);
+	}
+	HidD_GetHidGuid(&guid);
+	info = SetupDiGetClassDevs(&guid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
+	if (info == INVALID_HANDLE_VALUE) return 0;
+	for (index=0; 1 ;index++) {
+		iface.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
+		ret = SetupDiEnumDeviceInterfaces(info, NULL, &guid, index, &iface);
+		if (!ret) return count;
+		SetupDiGetInterfaceDeviceDetail(info, &iface, NULL, 0, &reqd_size, NULL);
+		details = (SP_DEVICE_INTERFACE_DETAIL_DATA *)malloc(reqd_size);
+		if (details == NULL) continue;
+
+		memset(details, 0, reqd_size);
+		details->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
+		ret = SetupDiGetDeviceInterfaceDetail(info, &iface, details,
+			reqd_size, NULL, NULL);
+		if (!ret) {
+			free(details);
+			continue;
+		}
+		h = CreateFile(details->DevicePath, GENERIC_READ|GENERIC_WRITE,
+			FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
+			OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
+		free(details);
+		if (h == INVALID_HANDLE_VALUE) continue;
+		attrib.Size = sizeof(HIDD_ATTRIBUTES);
+		ret = HidD_GetAttributes(h, &attrib);
+		//printf("vid: %4x\n", attrib.VendorID);
+		if (!ret || (vid > 0 && attrib.VendorID != vid) ||
+		  (pid > 0 && attrib.ProductID != pid) ||
+		  !HidD_GetPreparsedData(h, &hid_data)) {
+			CloseHandle(h);
+			continue;
+		}
+		if (!HidP_GetCaps(hid_data, &capabilities) ||
+		  (usage_page > 0 && capabilities.UsagePage != usage_page) ||
+		  (usage > 0 && capabilities.Usage != usage)) {
+			HidD_FreePreparsedData(hid_data);
+			CloseHandle(h);
+			continue;
+		}
+		HidD_FreePreparsedData(hid_data);
+		hid = (struct hid_struct *)malloc(sizeof(struct hid_struct));
+		if (!hid) {
+			CloseHandle(h);
+			continue;
+		}
+		hid->handle = h;
+		hid->open = 1;
+		add_hid(hid);
+		count++;
+		if (count >= max) return count;
+	}
+	return count;
+}
+
+
+//  rawhid_close - close a device
+//
+//    Inputs:
+//	num = device to close (zero based)
+//    Output
+//	(nothing)
+//
+void rawhid_close(int num)
+{
+	hid_t *hid;
+
+	hid = get_hid(num);
+	if (!hid || !hid->open) return;
+	hid_close(hid);
+}
+
+
+
+static void add_hid(hid_t *h)
+{
+	if (!first_hid || !last_hid) {
+		first_hid = last_hid = h;
+		h->next = h->prev = NULL;
+		return;
+	}
+	last_hid->next = h;
+	h->prev = last_hid;
+	h->next = NULL;
+	last_hid = h;
+}
+
+
+static hid_t * get_hid(int num)
+{
+	hid_t *p;
+	for (p = first_hid; p && num > 0; p = p->next, num--) ;
+	return p;
+}
+
+
+static void free_all_hid(void)
+{
+	hid_t *p, *q;
+
+	for (p = first_hid; p; p = p->next) {
+		hid_close(p);
+	}
+	p = first_hid;
+	while (p) {
+		q = p;
+		p = p->next;
+		free(q);
+	}
+	first_hid = last_hid = NULL;
+}
+
+
+static void hid_close(hid_t *hid)
+{
+	CloseHandle(hid->handle);
+	hid->handle = NULL;
+}
+
+
+void print_win32_err(void)
+{
+	char buf[256];
+	DWORD err;
+
+	err = GetLastError();
+	FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, err,
+		0, buf, sizeof(buf), NULL);
+	printf("err %ld: %s\n", err, buf);
+}
+
+
+
+
+

data/ext/rawhid/rawhid.c

@@ -0,0 +1,87 @@
+#include "ruby.h"
+//#include "ext_help.h"
+#include <errno.h>
+#include <inttypes.h>
+#include "hid.h"
+
+#define GET_RAWHID(name, val)         \
+  void               *name;           \
+  Data_Get_Struct(val, void, name)
+
+VALUE RawHID;
+VALUE RawHIDError;
+
+VALUE RawHID_new(VALUE class, VALUE vendorId, VALUE productId) {
+  void    *dev = NULL;
+  int      vId = NUM2INT(vendorId);
+  int      pId = NUM2INT(pId);
+  int      devices_opened = rawhid_open(1, &dev, vId, pId, -1, -1);
+  if(devices_opened == 0 || dev == NULL) {
+    rb_raise(RawHIDError, "Unable to open device");
+  }
+  
+  VALUE self = Data_Wrap_Struct(class, NULL, rawhid_close, dev);
+  return self;
+}
+
+VALUE RawHID_send(int argc, VALUE *argv, VALUE class) {
+  VALUE    data, timeout_val;
+  GET_RAWHID(dev, class);
+  
+  rb_scan_args(argc, argv, "11", &data, &timeout_val);
+  
+  char    *buf = StringValuePtr(data);
+  int      len = RSTRING_LEN(data);
+  int      timeout = (NIL_P(timeout_val)) ? 0 : NUM2INT(timeout_val);
+  
+  if(len == 0) {
+    return INT2NUM(0);
+  }
+  int sent = rawhid_send(dev, buf, len, timeout);
+  if(sent == -1) {
+    rb_raise(RawHIDError, "Error sending data to device");
+  }
+  return INT2NUM(sent);
+}
+
+VALUE RawHID_recv(int argc, VALUE *argv, VALUE class) {
+  VALUE    data, len_val, timeout_val;
+  GET_RAWHID(dev, class);
+  
+  rb_scan_args(argc, argv, "11", &len_val,  &timeout_val);
+  
+  int      len = NUM2INT(len_val);
+  int      timeout = (NIL_P(timeout_val)) ? 0 : NUM2INT(timeout_val);
+  char     staticbuf[64];
+  char    *buf=NULL;
+  
+  if(len <= 64) {
+    buf = staticbuf;
+  }
+  else {
+    buf = malloc(len);
+    if(!buf) {
+      rb_raise(RawHIDError, "Out of memory");
+    }
+  }
+  int received = rawhid_recv(dev, buf, len, timeout);
+  
+  if(received == -1) {
+    rb_raise(RawHIDError, "Error receiving data from device");
+  }
+  data = rb_str_new(buf, received);
+  return data;
+}
+
+void Init_rawhid() {
+  RawHID = rb_define_class("RawHID", rb_cObject);
+  RawHIDError = rb_define_class_under(RawHID, "RawHIDError", rb_eRuntimeError);
+  
+  rb_define_singleton_method(RawHID, "new", RawHID_new, 2);
+  rb_define_method(RawHID, "send", RawHID_send, -1);
+  rb_define_method(RawHID, "recv", RawHID_recv, -1);
+  
+}
+
+
+

data/ext/rawhid/rawhid_test.c

@@ -0,0 +1,100 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+#if defined(OS_LINUX) || defined(OS_MACOSX)
+#include <sys/ioctl.h>
+#include <termios.h>
+#elif defined(OS_WINDOWS)
+#include <conio.h>
+#endif
+
+#include "hid.h"
+
+
+static char get_keystroke(void);
+
+
+int main()
+{
+	int i, r, num;
+	char c, buf[64];
+
+	// C-based example is 16C0:0480:FFAB:0200
+	r = rawhid_open(1, 0x16C0, 0x0480, 0xFFAB, 0x0200);
+	if (r <= 0) {
+		// Arduino-based example is 16C0:0486:FFAB:0200
+		r = rawhid_open(1, 0x16C0, 0x0486, 0xFFAB, 0x0200);
+		if (r <= 0) {
+			printf("no rawhid device found\n");
+			return -1;
+		}
+	}
+	printf("found rawhid device\n");
+
+	while (1) {
+		// check if any Raw HID packet has arrived
+		num = rawhid_recv(0, buf, 64, 220);
+		if (num < 0) {
+			printf("\nerror reading, device went offline\n");
+			rawhid_close(0);
+			return 0;
+		}
+		if (num > 0) {
+			printf("\nrecv %d bytes:\n", num);
+			for (i=0; i<num; i++) {
+				printf("%02X ", buf[i] & 255);
+				if (i % 16 == 15 && i < num-1) printf("\n");
+			}
+			printf("\n");
+		}
+		// check if any input on stdin
+		while ((c = get_keystroke()) >= 32) {
+			printf("\ngot key '%c', sending...\n", c);
+			buf[0] = c;
+			for (i=1; i<64; i++) {
+				buf[i] = 0;
+			}
+			rawhid_send(0, buf, 64, 100);
+		}
+	}
+}
+
+#if defined(OS_LINUX) || defined(OS_MACOSX)
+// Linux (POSIX) implementation of _kbhit().
+// Morgan McGuire, morgan@cs.brown.edu
+static int _kbhit() {
+	static const int STDIN = 0;
+	static int initialized = 0;
+	int bytesWaiting;
+
+	if (!initialized) {
+		// Use termios to turn off line buffering
+		struct termios term;
+		tcgetattr(STDIN, &term);
+		term.c_lflag &= ~ICANON;
+		tcsetattr(STDIN, TCSANOW, &term);
+		setbuf(stdin, NULL);
+		initialized = 1;
+	}
+	ioctl(STDIN, FIONREAD, &bytesWaiting);
+	return bytesWaiting;
+}
+static char _getch(void) {
+	char c;
+	if (fread(&c, 1, 1, stdin) < 1) return 0;
+	return c;
+}
+#endif
+
+
+static char get_keystroke(void)
+{
+	if (_kbhit()) {
+		char c = _getch();
+		if (c >= 32) return c;
+	}
+	return 0;
+}
+
+

data/lib/rawhid/version.rb

@@ -0,0 +1,3 @@
+class RawHID
+  VERSION = "0.1.1"
+end

data/lib/rawhid.rb

@@ -0,0 +1,2 @@
+require "rawhid/version"
+require "rawhid/rawhid"

data/rawhid.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rawhid/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rawhid"
+  spec.version       = RawHID::VERSION
+  spec.authors       = ["Leo P."]
+  spec.email         = ["junk@slact.net"]
+
+  spec.summary       = "Ruby binding for Teensy RawHID C code"
+  spec.description   = "same as above"
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.extensions = ["ext/rawhid/extconf.rb"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: rawhid
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Leo P.
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: same as above
+email:
+- junk@slact.net
+executables: []
+extensions:
+- ext/rawhid/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/rawhid/Makefile
+- ext/rawhid/Makefile.bundled
+- ext/rawhid/extconf.h
+- ext/rawhid/extconf.rb
+- ext/rawhid/hid.h
+- ext/rawhid/hid_LINUX.c
+- ext/rawhid/hid_MACOSX.c
+- ext/rawhid/hid_WINDOWS.c
+- ext/rawhid/rawhid.c
+- ext/rawhid/rawhid_test.c
+- lib/rawhid.rb
+- lib/rawhid/version.rb
+- rawhid.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Ruby binding for Teensy RawHID C code
+test_files: []