msr 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e05a55f89cc5ba507959b75913957939f283e039
+  data.tar.gz: aef2815e7192bade10ed798c073b63049cf52587
+SHA512:
+  metadata.gz: b6e4beea042e4fba1ff9d87df4b8ce99175990b1e77f48761c9652089ae3d0a9a353e9aee1a57dd44129897bec799bb36ca66dbb5abfebc976449bf5b4f31600
+  data.tar.gz: 3b9c9e7f3049c7ff5a44d0499ad5c56eba6f0344f4e4a1d37db6937c9381abb25b5a68b763ef611e817b72c867c62dd5e30fb940019cbc1281d38d080f38a726

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 William Woodruff <william @ tuffbizz.com>
+
+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/README.md

@@ -0,0 +1,26 @@
+msr
+===
+
+A ruby gem for controlling magnetic stripe reader-writers (on UNIX/UNIX-likes).
+
+Uses [libmsr](https://github.com/woodruffw/libmsr).
+
+## Roadmap
+
+```ruby
+require 'msr'
+
+msr = MSR::MSR505C.new("/dev/ttyS0") # or your serial device
+
+puts "OK" if msr.linked?
+
+# control an LED on the reader
+msr.led!(:red) # :green, :yellow, :all, :off
+
+# get and set coercivity
+msr.coercivity # => :high, :low
+msr.coercivity = :high # :low
+
+# more to come
+```
+

data/ext/msr/extconf.rb

@@ -0,0 +1,4 @@
+require "mkmf"
+
+have_library("msr")
+create_makefile("ext/msr")

data/ext/msr/msr.c

@@ -0,0 +1,12 @@
+#include "msr.h"
+
+VALUE mMSR = Qnil;
+
+void Init_msr()
+{
+	mMSR = rb_define_module("MSR");
+
+	Init_msr_msr206();
+	Init_msr_track();
+	Init_msr_tracks();
+}

data/ext/msr/msr206.c

@@ -0,0 +1,251 @@
+#include "msr.h"
+
+VALUE cMSR_MSR206 = Qnil;
+
+static VALUE allocate(VALUE klass);
+static void deallocate_206_ctx(msr206_ctx_t *ctx);
+static VALUE initialize(VALUE self, VALUE rb_string);
+static VALUE comm_test(VALUE self);
+static VALUE sensor_test(VALUE self);
+static VALUE ram_test(VALUE self);
+static VALUE get_coercivity(VALUE self);
+static VALUE set_coercivity(VALUE self, VALUE co_sym);
+static VALUE set_bpi(VALUE self, VALUE bpi);
+static VALUE set_bpc(VALUE self, VALUE bpc);
+static VALUE set_led(VALUE self, VALUE led_sym);
+static VALUE raw_read(VALUE self);
+static VALUE iso_read(VALUE self);
+static VALUE raw_write(VALUE self, VALUE tks_obj);
+static VALUE iso_write(VALUE self, VALUE tks_obj);
+
+void Init_msr_msr206()
+{
+	cMSR_MSR206 = rb_define_class_under(mMSR, "MSR206", rb_cObject);
+	rb_define_alloc_func(cMSR_MSR206, allocate);
+	rb_define_method(cMSR_MSR206, "initialize", initialize, 1);
+	rb_define_method(cMSR_MSR206, "comm_test!", comm_test, 0);
+	rb_define_method(cMSR_MSR206, "sensor_test!", sensor_test, 0);
+	rb_define_method(cMSR_MSR206, "ram_test!", ram_test, 0);
+	rb_define_method(cMSR_MSR206, "coercivity", get_coercivity, 0);
+	rb_define_method(cMSR_MSR206, "coercivity=", set_coercivity, 1);
+	rb_define_method(cMSR_MSR206, "bpi=", set_bpi, 1);
+	rb_define_method(cMSR_MSR206, "bpc=", set_bpc, 1);
+	rb_define_method(cMSR_MSR206, "led=", set_led, 1);
+	rb_define_method(cMSR_MSR206, "raw_read", raw_read, 0);
+	rb_define_method(cMSR_MSR206, "iso_read", iso_read, 0);
+	rb_define_method(cMSR_MSR206, "raw_write", raw_write, 1);
+	rb_define_method(cMSR_MSR206, "iso_write", iso_write, 1);
+}
+
+static VALUE allocate(VALUE klass)
+{
+	msr206_ctx_t *ctx = ALLOC(msr206_ctx_t);
+
+	ctx->fd = -1;
+
+	return Data_Wrap_Struct(klass, NULL, deallocate_206_ctx, ctx);
+}
+
+static void deallocate_206_ctx(msr206_ctx_t *ctx)
+{
+	if (ctx->fd > 0) {
+		msr_serial_close(ctx->fd);
+	}
+
+	free(ctx);
+}
+
+static VALUE initialize(VALUE self, VALUE rb_path)
+{
+	msr206_ctx_t *ctx;
+	char *path_str;
+	int ret;
+
+	Check_Type(rb_path, T_STRING);
+	Data_Get_Struct(self, msr206_ctx_t, ctx);
+
+	path_str = StringValueCStr(rb_path);
+
+	ret = msr_serial_open(path_str, &(ctx->fd), MSR_BLOCKING, MSR_BAUD);
+
+	if (ret != LIBMSR_ERR_OK) {
+		rb_raise(rb_eRuntimeError, "Couldn't open the device (%d)", ret);
+	}
+
+	ret = msr_init(ctx->fd);
+
+	if (ret != LIBMSR_ERR_OK) {
+		rb_raise(rb_eRuntimeError, "Couldn't initialize the device (%d)", ret);
+	}
+
+	return self;
+}
+
+static VALUE comm_test(VALUE self)
+{
+	return Qnil;
+}
+
+static VALUE sensor_test(VALUE self)
+{
+	return Qnil;
+}
+
+static VALUE ram_test(VALUE self)
+{
+	return Qnil;
+}
+
+static VALUE get_coercivity(VALUE self)
+{
+	VALUE hi_co = ID2SYM(rb_intern("hi"));
+	VALUE lo_co = ID2SYM(rb_intern("lo"));
+	msr206_ctx_t *ctx;
+	int ret;
+
+	Data_Get_Struct(self, msr206_ctx_t, ctx);
+
+	ret = msr_get_co(ctx->fd);
+
+	if (ret == MSR_CO_HI) {
+		return hi_co;
+	}
+	else if (ret == MSR_CO_LO) {
+		return lo_co;
+	}
+	else {
+		rb_raise(rb_eRuntimeError, "Couldn't get coercivity (%d)", ret);
+	}
+}
+
+static VALUE set_coercivity(VALUE self, VALUE co_sym)
+{
+	VALUE hi_co = ID2SYM(rb_intern("hi"));
+	VALUE lo_co = ID2SYM(rb_intern("lo"));
+	msr206_ctx_t *ctx;
+	int ret;
+
+	Check_Type(co_sym, T_SYMBOL);
+	Data_Get_Struct(self, msr206_ctx_t, ctx);
+
+	if (co_sym == hi_co) {
+		ret = msr_set_hi_co(ctx->fd);
+	}
+	else if (co_sym == lo_co) {
+		ret = msr_set_lo_co(ctx->fd);
+	}
+	else {
+		rb_raise(rb_eArgError, "Unknown coercivity level");
+	}
+
+	if (ret != LIBMSR_ERR_OK) {
+		rb_raise(rb_eRuntimeError, "Couldn't change coercivity (%d)", ret);
+	}
+
+	return self;
+}
+
+static VALUE set_bpi(VALUE self, VALUE bpi)
+{
+	return Qnil;
+}
+
+static VALUE set_bpc(VALUE self, VALUE bpc)
+{
+	return Qnil;
+}
+
+static VALUE set_led(VALUE self, VALUE led_sym)
+{
+	VALUE all = ID2SYM(rb_intern("all"));
+	VALUE grn = ID2SYM(rb_intern("green"));
+	VALUE ylw = ID2SYM(rb_intern("yellow"));
+	VALUE red = ID2SYM(rb_intern("red"));
+	VALUE off = ID2SYM(rb_intern("none"));
+	msr206_ctx_t *ctx;
+	uint8_t led;
+
+	Check_Type(led_sym, T_SYMBOL);
+	Data_Get_Struct(self, msr206_ctx_t, ctx);
+
+	if (led_sym == all) {
+		led = MSR_CMD_LED_ON;
+	}
+	else if (led_sym == grn) {
+		led = MSR_CMD_LED_GRN_ON;
+	}
+	else if (led_sym == ylw) {
+		led = MSR_CMD_LED_YLW_ON;
+	}
+	else if (led_sym == red) {
+		led = MSR_CMD_LED_RED_ON;
+	}
+	else if (led_sym == off) {
+		led = MSR_CMD_LED_OFF;
+	}
+	else {
+		rb_raise(rb_eArgError, "Unknown LED color command");
+	}
+
+	msr_flash_led(ctx->fd, led);
+
+	return self;
+}
+
+static VALUE raw_read(VALUE self)
+{
+	msr206_ctx_t *ctx;
+	msr_tracks_t tks = {0};
+	int ret;
+	VALUE tks_obj;
+
+	Data_Get_Struct(self, msr206_ctx_t, ctx);
+
+	for (int i = 0; i < MSR_MAX_TRACKS; i++) {
+		tks.msr_tracks[i].msr_tk_len = MSR_MAX_TRACK_LEN;
+	}
+
+	ret = msr_raw_read(ctx->fd, &tks);
+
+	if (ret != LIBMSR_ERR_OK) {
+		rb_raise(rb_eRuntimeError, "Device read failed (%d)", ret);
+	}
+
+	tks_obj = msr_tracks_new(tks);
+
+	return tks_obj;
+}
+
+static VALUE iso_read(VALUE self)
+{
+	msr206_ctx_t *ctx;
+	msr_tracks_t tks = {0};
+	int ret;
+	VALUE tks_obj;
+
+	Data_Get_Struct(self, msr206_ctx_t, ctx);
+
+	for (int i = 0; i < MSR_MAX_TRACKS; i++) {
+		tks.msr_tracks[i].msr_tk_len = MSR_MAX_TRACK_LEN;
+	}
+
+	ret = msr_iso_read(ctx->fd, &tks);
+
+	if (ret != LIBMSR_ERR_OK) {
+		rb_raise(rb_eRuntimeError, "Device read failed (%d)", ret);
+	}
+
+	tks_obj = msr_tracks_new(tks);
+
+	return tks_obj;
+}
+
+static VALUE raw_write(VALUE self, VALUE tks_obj)
+{
+	return Qnil;
+}
+
+static VALUE iso_write(VALUE self, VALUE tks_obj)
+{
+	return Qnil;
+}

data/ext/msr/track.c

@@ -0,0 +1,63 @@
+#include "msr.h"
+
+static VALUE initialize(VALUE self, VALUE data);
+static VALUE msr_track_data(VALUE self);
+static VALUE msr_track_length(VALUE self);
+
+VALUE c_MSR_Track = Qnil;
+
+void Init_msr_track()
+{
+	c_MSR_Track = rb_define_class_under(mMSR, "Track", rb_cObject);
+
+	rb_define_const(c_MSR_Track, "MAX_TRACK_LEN", INT2NUM(MSR_MAX_TRACK_LEN));
+
+	rb_define_method(c_MSR_Track, "initialize", initialize, 1);
+	rb_define_method(c_MSR_Track, "data", msr_track_data, 0);
+	rb_define_method(c_MSR_Track, "length", msr_track_length, 0);
+}
+
+/*
+	A convenience function for instantiating a new MSR::Track in C.
+*/
+VALUE msr_track_new(msr_track_t tk)
+{
+	VALUE obj = rb_obj_alloc(c_MSR_Track);
+
+	VALUE tk_data_ary = rb_ary_new();
+
+	for (int i = 0; i < tk.msr_tk_len; i++) {
+		rb_ary_push(tk_data_ary, INT2NUM(tk.msr_tk_data[i]));
+	}
+
+	return initialize(obj, tk_data_ary);
+}
+
+static VALUE initialize(VALUE self, VALUE tk_data_ary)
+{
+	int tk_len;
+
+	Check_Type(tk_data_ary, T_ARRAY);
+
+	tk_len = RARRAY_LEN(tk_data_ary);
+
+	if (tk_len > MSR_MAX_TRACK_LEN) {
+		rb_raise(rb_eArgError, "Track >%d bytes", MSR_MAX_TRACK_LEN);
+	}
+
+	rb_iv_set(self, "@data", tk_data_ary);
+
+	return self;
+}
+
+static VALUE msr_track_data(VALUE self)
+{
+	return rb_iv_get(self, "@data");
+}
+
+static VALUE msr_track_length(VALUE self)
+{
+	VALUE tk_data_ary = rb_iv_get(self, "@data");
+
+	return INT2NUM(RARRAY_LEN(tk_data_ary));
+}

data/ext/msr/tracks.c

@@ -0,0 +1,67 @@
+#include "msr.h"
+
+static VALUE initialize(VALUE self, VALUE tk1, VALUE tk2, VALUE tk3);
+static VALUE msr_tracks_track1(VALUE self);
+static VALUE msr_tracks_track2(VALUE self);
+static VALUE msr_tracks_track3(VALUE self);
+
+VALUE c_MSR_Tracks = Qnil;
+
+void Init_msr_tracks()
+{
+	c_MSR_Tracks = rb_define_class_under(mMSR, "Tracks", rb_cObject);
+
+	rb_define_method(c_MSR_Tracks, "initialize", initialize, 3);
+	rb_define_method(c_MSR_Tracks, "track1", msr_tracks_track1, 0);
+	rb_define_method(c_MSR_Tracks, "track2", msr_tracks_track2, 0);
+	rb_define_method(c_MSR_Tracks, "track3", msr_tracks_track3, 0);
+}
+
+/*
+	A convenience function for instantiating a new MSR::Tracks in C.
+*/
+VALUE msr_tracks_new(msr_tracks_t tks)
+{
+	VALUE obj = rb_obj_alloc(c_MSR_Tracks);
+	VALUE tk1_obj = msr_track_new(tks.msr_tracks[0]);
+	VALUE tk2_obj = msr_track_new(tks.msr_tracks[1]);
+	VALUE tk3_obj = msr_track_new(tks.msr_tracks[2]);
+
+	return initialize(obj, tk1_obj, tk2_obj, tk3_obj);
+}
+
+static VALUE initialize(VALUE self, VALUE tk1, VALUE tk2, VALUE tk3)
+{
+	if (CLASS_OF(tk1) != c_MSR_Track) {
+		rb_raise(rb_eArgError, "expected track object for track 1");
+	}
+
+	if (CLASS_OF(tk2) != c_MSR_Track) {
+		rb_raise(rb_eArgError, "expected track object for track 2");
+	}
+
+	if (CLASS_OF(tk3) != c_MSR_Track) {
+		rb_raise(rb_eArgError, "expected track object for track 3");
+	}
+
+	rb_iv_set(self, "@track1", tk1);
+	rb_iv_set(self, "@track2", tk2);
+	rb_iv_set(self, "@track3", tk3);
+
+	return self;
+}
+
+static VALUE msr_tracks_track1(VALUE self)
+{
+	return rb_iv_get(self, "@track1");
+}
+
+static VALUE msr_tracks_track2(VALUE self)
+{
+	return rb_iv_get(self, "@track2");
+}
+
+static VALUE msr_tracks_track3(VALUE self)
+{
+	return rb_iv_get(self, "@track3");
+}

data/lib/msr.rb

@@ -0,0 +1,7 @@
+require_relative "../ext/msr/msr"
+require_relative "msr/track"
+require_relative "msr/msr206"
+
+module MSR
+  VERSION = "0.0.1".freeze
+end

data/lib/msr/msr206.rb

@@ -0,0 +1,4 @@
+module MSR
+  class MSR206
+  end
+end

data/lib/msr/track.rb

@@ -0,0 +1,4 @@
+module MSR
+  class Track
+  end
+end

data/lib/msr/tracks.rb

@@ -0,0 +1,4 @@
+module MSR
+  class Tracks
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: msr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- William Woodruff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-20 00:00:00.000000000 Z
+dependencies: []
+description: A library for controlling magnetic stripe reader/writers.
+email: william@tuffbizz.com
+executables: []
+extensions:
+- ext/msr/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- ext/msr/extconf.rb
+- ext/msr/msr.c
+- ext/msr/msr206.c
+- ext/msr/track.c
+- ext/msr/tracks.c
+- lib/msr.rb
+- lib/msr/msr206.rb
+- lib/msr/track.rb
+- lib/msr/tracks.rb
+homepage: https://github.com/woodruffw/ruby-msr
+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.5.1
+signing_key: 
+specification_version: 4
+summary: msr - magnetic stripe reader/writer library.
+test_files: []