libcx320 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c3547e9bba3f0346e0343c36dc511ff05d0cc5e244e6dc949be37b008d02e5b0
+  data.tar.gz: 4720512b76668f1ef5bb2d4fb80faf9e534378f7ba24b9e1b53e607e10bd1a55
+SHA512:
+  metadata.gz: 873e3f5201b0bbf394a495531762482ed9b199076f2d4f1eb4895407cefc811b5c9851e032822016e4c4c58ea643ef5fcd239efd0a672316e41131cd7472a293
+  data.tar.gz: 3f72f2761dcfac9803a37f92a8986fce7e3d5607c1c177f09b23c2237eb3eee1f2032416db2b1f5569bf0ad09f7aa89e86225de3c8e3901d45e36532e05abf55

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in libcx320.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Holger Arndt
+
+MIT License
+
+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,32 @@
+# Libcx320
+
+Driver for Retransfer Printer CX-320.
+Usable per PCP05CT.DLL on Windows or per direct LIBUSB access on any operating system.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'libcx320'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install libcx320
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/larskanis/libcx320 )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+
+task :gem => :build

data/lib/libcx320/c.rb

@@ -0,0 +1,41 @@
+require 'ffi'
+
+module LibCX320
+  module C
+    extend FFI::Library
+
+    ffi_lib 'PCP05CT.DLL'
+
+    # Get Handle
+    attach_function :CXCMD_ScanCX320, [:pointer, :pointer], :int
+    attach_function :CXCMD_ScanCX320Next, [:pointer, :pointer], :int
+
+    # Checks
+    attach_function :CXCMD_CheckIfConnected, [:pointer, :pointer], :bool
+    attach_function :CXCMD_TestUnitReady, [:int, :int], :int
+
+    # Print & CardControl
+    attach_function :CXCMD_ReadPosition, [:int, :int, :pointer], :int
+    attach_function :CXCMD_ImageOut, [:int, :int, :pointer, :int, :int, :int], :int
+    attach_function :CXCMD_DefineLUT, [:int, :int, :int, :int, :pointer], :int
+    attach_function :CXCMD_Print, [:int, :int, :int, :int, :int], :int
+    attach_function :CXCMD_LoadCard, [:int, :int, :int, :int, :int, :int], :int
+    attach_function :CXCMD_MoveCard, [:int, :int, :int, :int, :int, :int], :int
+    attach_function :CXCMD_RetransferAndEject, [:int, :int, :int], :int
+    attach_function :CXCMD_RetransferAndTurn, [:int, :int, :int], :int
+
+    # MS Encoding
+    attach_function :CXCMD_WriteMagData, [:int, :int, :pointer, :int, :int], :int
+    attach_function :CXCMD_ReadMagData, [:int, :int, :pointer, :pointer, :int], :int
+    attach_function :CXCMD_ICControl, [:int, :int, :int, :int], :int
+
+    # Reset
+    attach_function :CXCMD_RezeroUnit, [:int, :int], :int
+
+    # Infos & Settings
+    attach_function :CXCMD_ModeSense, [:int, :int, :int, :pointer], :int
+    attach_function :CXCMD_ModeSelect, [:int, :int, :int, :pointer], :int
+    attach_function :CXCMD_LogSense, [:int, :int, :int, :pointer], :int
+    attach_function :CXCMD_LogSelect, [:int, :int], :int
+  end
+end

data/lib/libcx320/cx320.rb

@@ -0,0 +1,422 @@
+
+module LibCX320
+  class CX320
+    attr_reader :dev
+
+    def initialize(dev)
+      @dev = dev
+    end
+
+    def self.devices(dev_type)
+      dev_type.devices.map do |dev|
+        self.new(dev)
+      end
+    end
+
+    def close
+      @dev.close if @dev
+    end
+
+    def ready?
+      @dev.ready?
+    end
+
+    def rezero_unit
+      @dev.rezero_unit
+    end
+
+    def get_current_card_position
+      resp = @dev.get_current_card_position
+
+      # PU (Position Unknown) - Byte 0 Bit 3
+      # 0: The card is in the printer unit.
+      # 1: No card in the printer unit
+      #
+      # Note: Printer reports PU = 1 even if any card is in the card hopper. Printer generates
+      # Check Condition if the card is being transported.
+      #
+      # Byte 7
+      # Position: Card position in the printer unit.
+      # 0: At Retransfer Position 1:At Contact IC Encoder 2: At No-Contact IC encoder
+      # 3: At MAG encoder Greater than 3: Reserved
+      #
+      # Byte 1 Bit 0
+      # Load Mode: The way to load the card
+      # 0: From the card tray
+      # 1: From the right side card entrance
+
+      card_position = { pu: nil, position: nil, load_mode: nil}
+      card_position[:pu] = resp.getbyte(0) & 0x4 != 0 ? :no_card_in_printer : :card_in_printer
+
+      card_position[:position] = case resp.getbyte(7)
+        when 0 then :retransfer
+        when 1 then :contact
+        when 2 then :contactless
+        when 3 then :magnetstripe
+        else raise "Invalid card_position: #{resp.getbyte(7).inspect}!"
+      end
+
+      card_position[:load_mode] = resp.getbyte(0) & 0x1 != 0 ? :right_side : :card_tray
+
+      card_position
+    end
+
+    ImageLayer2Code = {
+      K: 0,
+      C: 1,
+      M: 2,
+      Y: 3,
+      UV: 4,
+      PeelOff: 5
+    }
+
+    def image_out(layer, data, buffer=0)
+      buffer = Buffer2Code[buffer] || buffer
+      layer = ImageLayer2Code[layer] || layer
+
+      @dev.image_out(layer, data, buffer)
+    end
+
+    # Notice: As K LUT is used internally, K must not be specified.
+    LutLayer2Code = {
+      K: 0,
+      C: 2,
+      M: 4,
+      Y: 6
+    }
+    def lut=(layer, lut)
+      layer = LutLayer2Code[layer] ? LutLayer2Code[layer] : layer
+
+      data = FFI::MemoryPointer.new :char, 256
+      data.write_bytes lut
+
+      check_returncode C.CXCMD_DefineLUT(@slot, @id, data.size, data)
+    end
+
+    Buffer2Code = {
+      frontside: 0,
+      backside: 1,
+    }
+
+    PrintColor2Code = {
+      YMC: 0b1,
+      K: 0b10,
+      UV: 0b100,
+      PeelOff: 0b1000
+    }
+    def print(color=[:YMC, :K], buffer=0, async=false)
+      buffer = Buffer2Code[buffer] || buffer
+      color = color.map{|c| PrintColor2Code[c] }.inject(0, &:|) if color.kind_of?(Array)
+      async = async ? 1 : 0
+
+      @dev.print(color, buffer, async)
+    end
+
+    Position2Code = {
+      retransfer: 0,
+      contact: 1,
+      contactless: 2,
+      magnetstripe: 3,
+      eject: 4
+    }
+    def load_card(pos=:retransfer, flip=false, adjusted=false, async=false)
+      pos = Position2Code[pos] ? Position2Code[pos] : pos
+      flip = flip ? 1 : 0
+      adjusted = adjusted ? 1 : 0 # This setting is effective only when Destination is NG Card outlet
+      async = async ? 1 : 0
+
+      @dev.load_card(pos, flip, adjusted, async)
+    end
+
+    def move_card(pos=:retransfer, flip=false, adjusted=false, async=false)
+      pos = Position2Code[pos] ? Position2Code[pos] : pos
+      flip = flip ? 1 : 0
+      adjusted = adjusted ? 1 : 0 # This setting is effective only when Destination is NG Card outlet
+      async = async ? 1 : 0
+
+      @dev.move_card(pos, flip, adjusted, async)
+    end
+
+    def retransfer_and_eject(async=false)
+      async = async ? 1 : 0
+      @dev.retransfer_and_eject(async)
+    end
+
+    def retransfer_and_turn(async=false)
+      async = async ? 1 : 0
+      @dev.retransfer_and_turn(async)
+    end
+
+    MagFormat = {
+      jis2_7bit: [0x07, 69], # 69 charcters at most
+      iso1_6bit: [0x16, 76], # 76 charcters at most
+      iso1_7bit: [0x17, 69], # 69 charcters at most
+      iso2_4bit: [0x24, 37], # 37 charcters at most
+      iso3_4bit: [0x34, 104], # 104 charcters at most
+      iso3_7bit: [0x37, 69], # 69 charcters at most
+    }
+
+    def write_mag(format, data)
+      format, len = MagFormat[format] || format
+      @dev.write_mag(format, len, data)
+    end
+
+    def read_mag(format)
+      format, len = MagFormat[format] || format
+      @dev.read_mag(format, len)
+    end
+
+    IC_Types = {
+      contact: 0,
+      contactless: 1,
+    }
+
+    IC_Actions = {
+      contact: 0,
+      release: 1,
+    }
+
+    def ic_control(type, action)
+      type = IC_Types[type] || type
+      action = IC_Actions[action] || action
+      @dev.ic_control(type, action)
+    end
+
+    class AttrDescription < Struct.new(:name, :offs_read, :offs_write, :default, :typ, :params)
+      def to_attribute
+        ext_type, ext_params = case typ
+        when :byte
+          [ :int, params || (0..0xff) ]
+        when :word
+          [ :int, params || (0..0xffff) ]
+        when :dword
+          [ :int, params || (0..0xffffffff) ]
+        when :set, :ascii
+          [ typ, params ]
+        else
+          raise "invalid attr type #{typ}"
+        end
+        Attribute.new(name, !!offs_write, default, ext_type, ext_params)
+      end
+    end
+
+    Attribute = Struct.new(:name, :writeable, :default, :typ, :params, :value)
+
+    def self.to_attr_desc(hash)
+      hash.map do |key, args|
+        AttrDescription.new(key, *args).freeze
+      end.freeze
+    end
+
+    def self.make_range(hash)
+      byte_min = hash.inject(9999999){|m,(k, v)| [m, k].min }
+      byte_max = hash.inject(-9999999){|m,(k, v)| [m, k].max }
+      reverse = hash[byte_min].to_i > hash[byte_max].to_i
+      range = byte_min+1 .. byte_max-1
+      rhash = range.to_a.inject({}) do |h,k|
+        v = reverse ? byte_min + hash[byte_min].to_i - k : k - byte_min + hash[byte_min].to_i
+        h[k] = v.to_s # + " (#{k})"
+        h
+      end
+      rhash.merge(hash).sort_by{|k,v| k }.inject({}){|h,(k,v)| h[k]=v; h }
+    end
+
+    ModeSenseInkAttrs = to_attr_desc({
+      ink_code: [2, nil, nil, :set, {0x00 => 'YMCK', 0x02 => 'YMCK-PO', 0x03 => 'K', 0x04 => 'YMCKK', 0x05 => 'YMCK-UV'}],
+      ink_number_printed: [4, nil, nil, :word],
+      ink_lot_number: [8, nil, nil, :ascii, 6],
+    })
+
+    ModeSensePrintAttrs = to_attr_desc({
+      print_ink_code: [21, nil, nil, :set, {0 => 'YMCK', 2 => 'YMCK-PO', 3 => 'K', 4 => 'YMCKK', 5 => 'YMCK-UV'}],
+      print_resin_black_energy: [41, 13, 3, :set, make_range(0 => "-3 (bright)", 8 => "5 (dark)")],
+      print_resin_black_mode: [42, 14, 0, :set, {0 => 'Standard', 1 => 'Fine'}],
+      print_a0_energy: [43, 15, 3, :set, make_range(0 => "-3 (bright)", 8 => "5 (dark)")],
+      print_a1_energy: [44, 16, 3, :set, make_range(0 => "-3 (bright)", 8 => "5 (dark)")],
+      print_film_code: [20, 17, 0, :set, {0 => 'Standard (1000 panels)', 2 => 'Standard (750panels)'}],
+      print_roller_temp_retransfer: [33, 4, 4, :set, make_range(0 => "-3 (low)", 5 => "2 (high)")],
+      print_velocity_front: [34, 5, 0, :set, make_range(0 => "2 (Fast)", 12 => "-10 (Slow)")],
+      print_velocity_back: [35, 6, 0, :set, make_range(0 => "2 (Fast)", 12 => "-10 (Slow)")],
+
+      print_buzzer_mode: [45, 21, 0, :set, {0 => 'Buzzer is enabled', 1 => 'Buzzer is disabled'}],
+      print_power_save_minutes: [46, 22, 8, :set, {0 =>'5', 1 =>'10', 2 =>'15', 3 =>'20', 4 =>'25', 5 =>'30', 6 =>'45', 7 =>'60', 8 =>'Off'}],
+
+      print_roller_temp_card_fix: [36, 7, 3, :set, make_range(0 => "-5 (low)", 5 => "0 (high)").merge(10 => "Off")],
+      print_velocity_card_fix: [37, 8, 4, :set, make_range(0 => "-2 (slow)", 4 => "2 (fast)")],
+      print_peel_off_wait_seconds: [39, 10, 0, :byte, 0..15],
+
+      print_card_code: [22, 19, 0, :set, {0 => 'Standard', 2 => 'Thin card (Card thickness is 0.25mm)'}],
+      print_revision_number: [40, nil, nil, :byte],
+      print_film_quantity: [47, nil, nil, :byte, 0..10],
+      print_ink_quantity: [48, nil, nil, :byte, 0..50],
+      print_card_quantity: [49, nil, nil, :set, {0 => 'Greater than 25 cards', 1 => 'From 1 to 24 cards', 2 => 'No cards', 3 => 'Right Side Card loading mode'}],
+      print_resolution_x: [4, nil, nil, :word],
+      print_resolution_y: [6, nil, nil, :word],
+      print_card_size_x: [12, nil, nil, :word],
+      print_card_size_y: [14, nil, nil, :word],
+      print_mg_mode: [17, nil, nil, :set, {0 => 'None', 1 => 'MAG Encoder', 2 => 'JIS MAG Encoder'}],
+      print_ic_mode_contactless: [19, nil, nil, :set, {0 => 'None', 2 => 'External small IC Encoder', 3 => 'External large IC Encoder'}],
+      print_ic_mode_contact: [18, nil, nil, :set, {0 => 'None', 1 => 'Embedded IC Encoder', 2 => 'External IC Encoder'}],
+      print_position_x: [24, nil, nil, :word],
+      print_position_y: [26, nil, nil, :word],
+      print_size_x: [28, nil, nil, :word],
+      print_size_y: [30, nil, nil, :word],
+    })
+
+    ModeSenseEncodeAttrs = to_attr_desc({
+      mag_iso_mode: [2, 2, 0, :set, {0 => 'No ISO MAG encoder', 1 => '300 Oe (Lo-Co)', 2 => '2750 Oe (Hi-Co)'}],
+      mag_read_write_retry: [7, 7, 0, :byte, 0..3],
+    })
+
+    ModeSensePages = {
+      ink: [0x23, 4+40, [[ModeSenseInkAttrs, 0]]],
+      print: [0x28, 4+50, [[ModeSensePrintAttrs, 0]]],
+      mag: [0x2a, 4+10, [[ModeSenseEncodeAttrs, 0]]],
+      all: [0x3f, 4+100, [[ModeSenseInkAttrs, 0], [ModeSensePrintAttrs, 40], [ModeSenseEncodeAttrs, 40+50]]],
+    }
+
+    LogSenseAttrs = to_attr_desc({
+      log_total_count: [8, nil, nil, :dword],
+      log_free_count: [16, nil, nil, :dword],
+      log_head_count: [24, nil, nil, :dword],
+      log_cleaning_count: [32, nil, nil, :dword],
+    })
+
+    LogSensePages = {
+      log: [0x38, 36, [[LogSenseAttrs, 0]]],
+    }
+
+    def mode_sense(page_sym)
+      page, len, attr_lists = ModeSensePages[page_sym] || raise("invalid page: #{page_sym.inspect} not in #{ModeSensePages.keys.inspect}")
+      data = @dev.mode_sense(page, len)[4..-1]
+      lists = attr_lists.map do |attr_list, offset|
+        data_to_attrs(data[offset..-1], attr_list)
+      end
+      lists.inject([], &:+)
+    end
+
+    ModeSelectPages = {
+      print: [0x28, 23, [[ModeSensePrintAttrs, 0]]],
+      mag: [0x2a, 10, [[ModeSenseEncodeAttrs, 0]]],
+    }
+
+    def mode_select(page_sym, attrs={})
+      page, len, attr_lists = ModeSelectPages[page_sym] || raise("invalid page: #{page_sym.inspect} not in #{ModeSelectPages.keys.inspect}")
+
+      data = [0].pack("C") * len
+      data[0, 2] = [0x28, 0x15].pack("CC") if page == 0x28
+      data[0, 2] = [0x2a, 0x08].pack("CC") if page == 0x2a
+      lists = attr_lists.map do |attr_list, offset|
+        data[offset..-1] = attrs_to_data(attr_list, data[offset..-1], attrs)
+      end
+      raise "invalid data length #{data.bytesize}" if data.bytesize != len
+      @dev.mode_select(page, data)
+    end
+
+    def log_sense(page_sym)
+      page, len, attr_lists = LogSensePages[page_sym] || raise("invalid page: #{page_sym.inspect} not in #{LogSensePages.keys.inspect}")
+      data = @dev.log_sense(page, len)
+      lists = attr_lists.map do |attr_list, offset|
+        data_to_attrs(data[offset..-1], attr_list)
+      end
+      lists.inject([], &:+)
+    end
+
+    def log_select
+      @dev.log_select
+    end
+
+    def self.mode_sense_attrs(page_sym)
+      _page, _len, attr_lists = ModeSensePages[page_sym] || raise("invalid page: #{page_sym.inspect} not in #{ModeSensePages.keys.inspect}")
+      attr_lists.map(&:first).inject([], &:+).map{|a| a.to_attribute }
+    end
+
+    def self.log_sense_attrs(page_sym)
+      _page, _len, attr_lists = LogSensePages[page_sym] || raise("invalid page: #{page_sym.inspect} not in #{LogSensePages.keys.inspect}")
+      attr_lists.map(&:first).inject([], &:+).map{|a| a.to_attribute }
+    end
+
+    private
+
+    def data_to_attrs(data, attr_list)
+      attr_list.map do |attr|
+        val = case attr.typ
+        when :byte
+          data[attr.offs_read, 1].getbyte(0)
+        when :word
+          data[attr.offs_read, 2].unpack("n")[0]
+        when :dword
+          data[attr.offs_read, 4].unpack("N")[0]
+        when :set
+          data[attr.offs_read, 1].getbyte(0)
+        when :ascii
+          data[attr.offs_read, attr.params]
+        else
+          raise "invalid attr type #{attr.typ}"
+        end
+
+        nattr = attr.to_attribute
+        nattr.value = val
+        nattr
+      end
+    end
+
+    def attrs_to_data(attr_list, data, attrs)
+      data = data.dup
+      attrs.each do |name, value|
+        attr = attr_list.find{|a| a.name.to_s == name.to_s }
+        raise("invalid attr name #{name.inspect}") unless attr
+
+        case attr.typ
+        when :byte
+          if attr.params
+            raise("value out of range #{attr.params.inspect}: #{value.inspect}") unless attr.params === value
+          end
+          data[attr.offs_write, 1] = [value].pack("C")
+        when :word
+          if attr.params
+            raise("value out of range #{attr.params.inspect}: #{value.inspect}") unless attr.params === value
+          end
+          data[attr.offs_write, 2] = [value].pack("n")
+        when :dword
+          if attr.params
+            raise("value out of range #{attr.params.inspect}: #{value.inspect}") unless attr.params === value
+          end
+          data[attr.offs_write, 4] = [value].pack("N")
+        when :set
+          val = case value
+          when Integer then value
+          when String
+            attr.params[value] || raise("invalid set value #{value.inspect}")
+          else
+            raise("invalid set value #{value.inspect}")
+          end
+          data[attr.offs_write, 1] = [value].pack("C")
+        when :ascii
+          data[attr.offs_write, attr.params] = value
+        else
+          raise "invalid attr type #{attr.typ}"
+        end
+      end
+      data
+    end
+  end
+
+  class CX320_DLL < CX320
+    def self.devices(*args)
+      super(DeviceDll, *args)
+    end
+  end
+
+  class CX320_USB < CX320
+    def self.devices(*args)
+      super(DeviceUsb, *args)
+    end
+  end
+
+  class CX320_SIMU < CX320
+    def self.devices(*args)
+      super(DeviceSimu, *args)
+    end
+  end
+end

data/lib/libcx320/device_dll.rb

@@ -0,0 +1,130 @@
+require 'libcx320/c'
+
+module LibCX320
+  class DeviceDll
+    extend ErrorHandling
+    include ErrorHandling
+
+    def self.devices
+      slot = FFI::MemoryPointer.new :int
+      id = FFI::MemoryPointer.new :int
+
+      devs = [];
+      begin
+        check_returncode C.CXCMD_ScanCX320(slot, id)
+      rescue NoPrinter, NoMorePrinter
+      else
+        devs << new(slot.read_int, id.read_int)
+      end
+
+      loop do
+        slot.write_int slot.read_int
+        id.write_int id.read_int
+
+        begin
+          check_returncode C.CXCMD_ScanCX320Next(slot, id)
+        rescue NoPrinter, NoMorePrinter
+          # Suche beim ersten Fehler beenden
+          break
+        else
+          devs << new(slot.read_int, id.read_int)
+        end
+      end
+      devs
+    end
+
+    def initialize(slot, id)
+      @slot = slot
+      @id = id
+    end
+
+    def connected?
+      slot = FFI::MemoryPointer.new :int
+      slot.write_int @slot
+      id = FFI::MemoryPointer.new :int
+      id.write_int @id
+
+      C.CXCMD_CheckIfConnected(slot, id)
+    end
+
+    def close
+    end
+
+    def ready?
+      check_returncode C.CXCMD_TestUnitReady(@slot, @id)
+    end
+
+    def rezero_unit
+      check_returncode C.CXCMD_RezeroUnit(@slot, @id)
+    end
+
+    def get_current_card_position
+      pos = FFI::MemoryPointer.new :char, 8
+      check_returncode C.CXCMD_ReadPosition(@slot, @id, pos)
+      pos.read_bytes(8)
+    end
+
+    def image_out(layer, data, buffer)
+      check_returncode C.CXCMD_ImageOut(@slot, @id, data, data.size, layer, buffer)
+    end
+
+    def print(color, buffer, async)
+      check_returncode C.CXCMD_Print(@slot, @id, color, buffer, async)
+    end
+
+    def load_card(pos, flip, adjusted, async)
+      check_returncode C.CXCMD_LoadCard(@slot, @id, pos, flip, adjusted, async)
+    end
+
+    def move_card(pos, flip, adjusted, async)
+      check_returncode C.CXCMD_MoveCard(@slot, @id, pos, flip, adjusted, async)
+    end
+
+    def retransfer_and_eject(async)
+      check_returncode C.CXCMD_RetransferAndEject(@slot, @id, async)
+    end
+
+    def retransfer_and_turn(async)
+      check_returncode C.CXCMD_RetransferAndTurn(@slot, @id, async)
+    end
+
+
+    def write_mag(format, _len, data)
+      cdata = FFI::MemoryPointer.from_string(data)
+      check_returncode C.CXCMD_WriteMagData(@slot, @id, cdata, data.bytesize, format)
+    end
+
+    def read_mag(format, _len)
+      cdata = FFI::MemoryPointer.new(:char, 105)
+      clen = FFI::MemoryPointer.new(:int)
+      clen.write_int cdata.size
+      check_returncode C.CXCMD_ReadMagData(@slot, @id, cdata, clen, format)
+      cdata.get_bytes(0, clen.read_int)
+    end
+
+    def ic_control(type, action)
+      check_returncode C.CXCMD_ICControl(@slot, @id, type, action)
+    end
+
+    def mode_sense(page, len)
+      cdata = FFI::MemoryPointer.new(:char, len)
+      check_returncode C.CXCMD_ModeSense(@slot, @id, page, cdata)
+      cdata.get_bytes(0, cdata.size)
+    end
+
+    def mode_select(page, data)
+      cdata = FFI::MemoryPointer.from_string(data)
+      check_returncode C.CXCMD_ModeSelect(@slot, @id, page, cdata)
+    end
+
+    def log_sense(page, len)
+      cdata = FFI::MemoryPointer.new(:char, len)
+      check_returncode C.CXCMD_LogSense(@slot, @id, page, cdata)
+      cdata.get_bytes(0, cdata.size)
+    end
+
+    def log_select
+      check_returncode C.CXCMD_LogSelect(@slot, @id)
+    end
+  end
+end

data/lib/libcx320/device_simu.rb

@@ -0,0 +1,132 @@
+module LibCX320
+  class DeviceSimu
+    include ErrorHandling
+
+    def self.devices
+      2.times.map do |idx|
+        new(idx)
+      end
+    end
+
+    def initialize(devidx)
+      @devidx = devidx
+      @buffers = [{}, {}]
+      @card_pos = nil
+      @config = {
+        0x23 => ["23:26:00:00:03:e8:00:00:59:48:34:31:34:31:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00:00".gsub(":","")].pack("H*"),
+        0x28 => ["28:30:00:00:01:2c:01:2c:00:00:00:00:03:f5:02:7f:00:00:00:02:00:00:00:00:00:00:00:00:04:0c:02:98:00:04:00:00:03:04:00:00:01:03:00:03:03:00:03:06:22:01".gsub(":","")].pack("H*"),
+        0x2a => ["2a:08:00:00:00:00:00:00:00:00".gsub(":","")].pack("H*"),
+        0x38 => ["38:00:00:20:00:00:00:04:00:00:00:f5:00:01:00:04:00:00:00:00:00:02:00:04:00:00:04:90:00:03:00:04:00:00:00:f5".gsub(":","")].pack("H*"),
+      }
+      @config[0x3f] = @config[0x23] + @config[0x28] + @config[0x2a]
+    end
+
+    def close
+    end
+
+    def send_inquiry
+      "x" * 60
+    end
+
+    def log(text)
+      puts text
+    end
+    private :log
+
+    def ready?
+      log "ready?"
+    end
+
+    def rezero_unit
+      log "rezero_unit"
+    end
+
+    def get_current_card_position
+      [@card_pos ? 0x04 : 0x00, 0, 0, 0, 0, 0, 0, @card_pos].pack("CCCCCCCC")
+    end
+
+    def image_out(layer, data, buffer)
+      @buffers[buffer][layer] = data
+    end
+
+    def print(color, buffer, async)
+      log "print(#{color}, #{buffer}, #{async})"
+
+      if @buffers[buffer][1] && @buffers[buffer][2] && @buffers[buffer][3]
+        pic = Magick::Image.new(1036, 664)
+        pic.import_pixels(0, 0, 1036, 664, "R", @buffers[buffer][1])
+        pic.import_pixels(0, 0, 1036, 664, "G", @buffers[buffer][2])
+        pic.import_pixels(0, 0, 1036, 664, "B", @buffers[buffer][3])
+        begin
+          pic.display
+        rescue
+          pic.write("cx320-cmy.jpeg")
+        end
+      end
+      if @buffers[buffer][0]
+        pic = Magick::Image.new(1036, 664)
+        %w[R G B].each do |color|
+          pic.import_pixels(0, 0, 1036, 664, color, @buffers[buffer][0])
+        end
+        begin
+          pic.display
+        rescue
+          pic.write("cx320-k.jpeg")
+        end
+      end
+    end
+
+    def load_card(pos, flip, adjusted, async)
+      log "load_move_card(#{pos}, #{flip}, #{adjusted}, #{async})"
+      raise CommandSequenceError.new("card is already loaded", -0x01052A00) if @card_pos
+      @card_pos = pos
+    end
+
+    def move_card(pos, flip, adjusted, async)
+      log "load_move_card(#{pos}, #{flip}, #{adjusted}, #{async})"
+      raise CommandSequenceError.new("no card loaded", -0x01052A00) unless @card_pos
+      @card_pos = pos
+    end
+
+    def retransfer_and_eject(async)
+      log "load_move_card(#{async})"
+      raise CommandSequenceError.new("card is not in position retransfer", -0x01052A00) if @card_pos != 0
+      @card_pos = nil
+    end
+
+    def retransfer_and_turn(async)
+      log "load_move_card(#{async})"
+      raise CommandSequenceError.new("card is not in position retransfer", -0x01052A00) if @card_pos != 0
+    end
+
+    def write_mag(format, len, data)
+      log "write_mag(#{format}, #{len}, #{data.inspect})"
+    end
+
+    def read_mag(format, len)
+      "x" * len
+    end
+
+    def ic_control(type, action)
+      log "write_mag(#{type}, #{action})"
+    end
+
+    def mode_sense(page, len)
+      log "mode_sense(#{page}, #{len})"
+      [len - 1, 0, 0x10, 0].pack("CCCC") + @config[page]
+    end
+
+    def mode_select(page, data)
+      log "mode_select(#{page}, #{data.unpack("H*")[0]})"
+    end
+
+    def log_sense(page, len)
+      log "log_sense(#{page}, #{len})"
+      @config[page]
+    end
+
+    def log_select
+      log "log_select()"
+    end
+  end
+end

data/lib/libcx320/device_usb.rb

@@ -0,0 +1,220 @@
+require 'libusb'
+
+module LibCX320
+  class DeviceUsb
+    include ErrorHandling
+
+    attr_reader :devh
+
+    def self.devices
+      @@ctx = LIBUSB::Context.new
+
+      @@ctx.devices(idVendor: 0x04f1, idProduct: [0x4030, 0x4033]).map.with_index do |dev, devidx|
+        new(dev, devidx)
+      end
+    end
+
+    def bulk_transfer(**kwargs)
+      puts kwargs.inspect[0, 90]
+      @devh.bulk_transfer(**kwargs)
+    end
+
+    def send_command(cdb, data_length, direction=LIBUSB::ENDPOINT_IN)
+      ensure_open
+      @tag += 1
+      expected_tag = @tag
+      lun = 0
+      len = direction==LIBUSB::ENDPOINT_IN ? data_length : data_length.bytesize
+
+      cbw = ['USBC', expected_tag, len || 0, direction, lun, cdb.length, cdb].pack('a*VVCCCa*')
+      cbw = cbw.ljust(31, "\0")
+
+      bulk_transfer(endpoint: 0x02, dataOut: cbw)
+
+      if data_length && direction==LIBUSB::ENDPOINT_IN
+        recv = bulk_transfer(endpoint: 0x81, dataIn: data_length)
+        if recv[0,4] == "USBC".freeze
+          return check_status_urb(recv, expected_tag)
+        end
+      elsif data_length
+        recv_len = 0
+        while data_length && !data_length.empty?
+          begin
+            edata = data_length.slice!(0...0x10000)
+            recv_len += bulk_transfer(endpoint: 0x02, dataOut: edata)
+          rescue LIBUSB::ERROR_PIPE
+            @devh.clear_halt(0x02)
+            recv = bulk_transfer(endpoint: 0x81, dataIn: 13, timeout: 1)
+            return check_status_urb(recv, expected_tag)
+          end
+        end
+      end
+
+      retries = 5
+      begin
+        buffer = bulk_transfer(endpoint: 0x81, dataIn: 13, timeout: 999999999)
+        check_status_urb(buffer, expected_tag)
+      rescue LIBUSB::ERROR_PIPE, UnexpectedPacket
+        if (retries-=1)>=0
+          @devh.clear_halt(0x81)
+          retry
+        end
+        raise
+      end
+
+      return recv
+    end
+
+    def check_status_urb(buffer, expected_tag)
+      dCSWSignature, dCSWTag, dCSWDataResidue, bCSWStatus = buffer.unpack('a4VVC')
+
+      raise UnexpectedPacket, "Unexpected USB packet received" if expected_tag != dCSWTag
+      if bCSWStatus != 0
+        check_returncode(request_sense_error)
+      end
+    end
+
+    def initialize(dev, devidx)
+      @dev = dev
+      @devidx = devidx
+      @tag = 0
+      @devh = nil
+    end
+
+    def ensure_open
+      return @devh if @devh
+      @devh = @dev.open
+      @devh.claim_interface(0)
+
+      # loop do
+        # begin
+          # bulk_transfer(endpoint: 0x02, dataOut: "USBC\x01\x00\x00\x00`\x00\x00\x00\x80\x00\x06\x12\x00\x00\x00`\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+          # p ["clear"]
+          # bulk_transfer(endpoint: 0x81, dataIn: 1300, timeout: 100)
+        # rescue LIBUSB::ERROR_TIMEOUT
+          # break
+        # end
+      # end
+
+      send_inquiry
+
+      @devh
+    end
+
+    def close
+      if @devh
+        @devh.release_interface(0)
+        @devh.close
+      end
+    end
+
+    def send_inquiry
+      expected_length = 0x60 # INQUIRY_LENGTH
+      cdb = [ 0x12, 0, 0, # Inquiry
+              expected_length, 0,
+              ].pack('CCCnC')
+
+      send_command( cdb, expected_length )
+    end
+
+    def request_sense_error
+      expected_length = 0x14
+      cdb = [ 0x03, 0, 0, expected_length, 0].pack('CCCnC')
+      res = send_command( cdb, expected_length )
+
+      -( 0x01 << 24 | res.getbyte(0x02) << 16 | res.getbyte(0x0c) << 8 | 0 )
+    end
+
+    def ready?
+      cdb = [ 0, 0].pack('Nn')
+      send_command( cdb, nil)
+    end
+
+    def rezero_unit
+      cdb = [ 1, 0, 0].pack('CCN')
+      send_command( cdb, nil)
+    end
+
+    def get_current_card_position
+      start = 0
+      cdb = [ 0x34, 0, # Pre-Fetch(10)
+              start, 0,
+              0, 0,
+              ].pack('CCNCnC')
+      expected_length = 0x08
+
+      send_command(cdb, expected_length)
+    end
+
+    def image_out(layer, data, buffer)
+      cdb = [ 0x2a, 0, layer + buffer*8, 0, 0, data.bytesize, 0].pack('CCCCCNC')
+      send_command( cdb, data, LIBUSB::ENDPOINT_OUT )
+    end
+
+    def load_move_card(scode, p1, p2, pos)
+      cdb = [ 0x31, scode, # load card
+              p1, 0,
+              p2, 0, pos, 0,
+              ].pack('CCCCCnCn')
+      send_command(cdb, nil)
+    end
+
+    def print(color, buffer, async)
+      load_move_card(0x08, async + color*2, buffer, 0)
+    end
+
+    def load_card(pos, flip, adjusted, async)
+      load_move_card(0x01, async, flip*2 + adjusted*4, pos)
+    end
+
+    def move_card(pos, flip, adjusted, async)
+      load_move_card(0x0b, async, flip*2 + adjusted*4, pos)
+    end
+
+    def retransfer_and_eject(async)
+      load_move_card(0x09, async, 0, 0)
+    end
+
+    def retransfer_and_turn(async)
+      load_move_card(0x0a, async, 0, 0)
+    end
+
+
+    def write_mag(format, len, data)
+      cdb = [ 0x2f, 0, format, 0, data.bytesize, 0].pack('CNCCnC')
+      send_command( cdb, data, LIBUSB::ENDPOINT_OUT )
+    end
+
+    def read_mag(format, len)
+      cdb = [ 0x2e, 0, format, 0, len, 0].pack('CNCCnC')
+      send_command( cdb, len )
+    end
+
+    def ic_control(type, action)
+      cdb = [ 0x32, type*4 + action, 0, 0].pack('CCNN')
+      send_command( cdb, nil )
+    end
+
+    def mode_sense(page, len)
+      expected_length = len
+      cdb = [ 0x1a, 0, page, 0, expected_length, 0].pack('CCCCCC')
+      send_command( cdb, expected_length )
+    end
+
+    def mode_select(page, data)
+      cdb = [ 0x15, 0x10, page, 0, data.bytesize, 0].pack('CCCCCC')
+      send_command( cdb, data, LIBUSB::ENDPOINT_OUT )
+    end
+
+    def log_sense(page, len)
+      expected_length = len
+      cdb = [ 0x4d, 0, 0x40  | page, 0, 0, expected_length, 0].pack('CCCnnnC')
+      send_command( cdb, expected_length )
+    end
+
+    def log_select
+      cdb = [ 0x4c, 0x03, 0xc0, 0x00, 0].pack('CCCCN')
+      send_command( cdb, nil )
+    end
+  end
+end

data/lib/libcx320/error_handling.rb

@@ -0,0 +1,129 @@
+module LibCX320
+  module ErrorHandling
+    class Error < RuntimeError
+    end
+
+    class UnexpectedPacket < Error
+    end
+
+    class PrinterError < Error
+      attr_reader :code
+      def initialize(text, code)
+        super(text)
+        @code = code
+      end
+    end
+
+    class UnknownPrinterError < PrinterError
+    end
+
+    class BusyError < PrinterError
+    end
+
+    ErrorById = {
+      0x0102D000 => ["No card", "There is no card, or the hopper tray is not closed."],
+      0x0102D100 => ["Door Open", "Printer door is opened."],
+      0x0102D300 => ["Busy of Transporting", "Busy because of transporting card or retransferring. Note: This error is not returnd from functions. Control Function returns positive value as BUSY."],
+      0x0102D400 => ["Busy of Printing", "Busy because of printing. Note: This error is not returnd from functions. Control Function returns positive value as BUSY."],
+      0x0102D500 => ["Busy of Transporting and Printing", "Busy because of both “Busy of Transporting” and “Busy of Transporting and Printing”. Note: This error is not returnd from functions. Control Function returns positive value as BUSY."],
+      0x0102D600 => ["No Cassette", "Ink ribbon cassette is not attached, or/and Retransfer film cassette is not attached."],
+      0x0102D700 => ["No Cleaning Ro.", "Cleaning roller is not attached."],
+      0x0102DA00 => ["Preheating", "Printer is on the way of preheating."],
+      0x0102DB00 => ["Initializing", "Printer is on the way of initializing."],
+      0x0102DC00 => ["Testing or Cleaning", "Printer is on the way of Off-line Test or cleaning."],
+      0x0102DD00 => ["On Setting or Transport Mode", "Printer is in the setting mode or transporting mode."],
+      0x0102DE00 => ["Not Ready for Download", "Firmware download cannot be done as printer is not in Download mode."],
+      0x0102FD00 => ["Sleeping", "Printer is in the power save mode. Note) To exit this, initializing printer, which is pressing ENTER button after RESET button or sending REZERO command, is required."],
+      0x0102FE00 => ["Password Error", "Password certification is not done."],
+
+
+      0x01039000 => ["Jam(Hopper)", "The card does not arrive the card supply sensor within a predefined time."],
+      0x01039100 => ["Jam(TurnOver)", "The card does not arrive the sensor inside the turnover unit within a predefined time."],
+      0x01039200 => ["Jam(MG)", "The card does not arrive at the card edge sensor within a predefined time after leaving turnover unit. Also in case of magnetic encoding, when detection by the start position sensor of the MG unit is not possible."],
+      0x01039300 => ["Jam(Transfer)", "The card does not arrive the card outlet sensor within a predefined time after leaving the card edge sensor."],
+      0x01039400 => ["Jam(Discharge)", "The card stops at the card outlet sensor."],
+      0x01039500 => ["Load Failure", "The card is not loaded within 10 seconds in Right Side Card Loading mode. Note) Load Card command can be accepted even if this error is activated."],
+      0x0103A000 => ["Media Broken", "Retransfer film is broken."],
+      0x0103A100 => ["Media Search", "Mark on the retransfer film could not be detected."],
+      0x0103AD00 => ["MG Write Error", "Writing error to the magnetic stripe happens."],
+      0x0103AE00 => ["MG Read Error", "Reading error from the magnetic stripe happens."],
+      0x0103B000 => ["Ink Broken", "Ink ribbon is broken."],
+      0x0103B100 => ["Ink Search", "Mark on the ink ribbon could not be detected, or TAG on the ink ribbon is invalid."],
+      0x0103BB00 => ["EXT. Jam", "Card jam happens in the external IC unit."],
+
+
+      0x01044400 => ["Hardware Timeout", "Time out was detected by the printer firmware."],
+      0x0104A900 => ["MG Unconnected", "MG unit is not attached correctly."],
+      0x0104AB00 => ["MG Mechanical", "Mechanical error happens in the MG unit."],
+      0x0104AC00 => ["MG Hardware", "Hardware error happens in the MG unit."],
+      0x0104AF00 => ["MG Communicate", "Communication error happens between printer and MG unit."],
+      0x0104B900 => ["EXT. Unconnected", "External IC unit is not attached correctly."],
+      0x0104BA00 => ["EXT. SW Setting", "Dip switch setting in the external IC unit is not correct."],
+      0x0104BE00 => ["EXT. Communicate", "Communication error happens between printer and external IC unit."],
+      0x0104BF00 => ["EXT2. Communicate", "Communication error happens between printer and laminator."],
+      0x0104C000 => ["Turn Over Unit", "Turnover unit is out of order."],
+      0x0104C100 => ["Heater Cam", "Heater Cam is out order."],
+      0x0104D800 => ["Hardware", "Circuit trouble was detected at the initialization. Ex. Vth power cannot be put out from the power supply unit."],
+      0x0104F000 => ["TR Overheat", "The temperature of retransfer roller is too hot."],
+      0x0104F100 => ["TR Broken", "Retransfer roller is out of order."],
+      0x0104F200 => ["TR Sensor Broken", "Retransfer roller thermister is out of order."],
+      0x0104F300 => ["RR Overheat", "The temperature of bend remdil roller is too hot."],
+      0x0104F400 => ["RR Broken", "Bend remdil roller is out of order."],
+      0x0104F500 => ["RR Sensor Broken", "Bend remdil roller thermister is out of order."],
+      0x0104F600 => ["Overcool", "The temperature in the printer is too cool."],
+      0x0104F800 => ["Head Overheat", "The temperature of the thermal head is too hot."],
+      0x0104FA00 => ["EEPROM Broken", "EEPROM on the CPU circuit board or the head EEPROM is defective."],
+
+
+      0x01051A00 => ["Parameter List Length Error", "The content of command is invalid. Parameter list length value in CDB or Page Data is invalid."],
+      0x01052000 => ["Invalid Command Operation Code", "The content of command is invalid. Operation Code in CDB is invalid."],
+      0x01052400 => ["Illegal Field in CDB", "The content of command is invalid. The data in CDB is invalid."],
+      0x01052500 => ["Invalid LUN", "The content of command is invalid. LUN value in CDB is invalid."],
+      0x01052600 => ["Invalid Field in Parameter List", "The content of command is invalid. The data in Page Data is invalid."],
+      0x01052700 => ["Invalid Color Code in CDB", "Invalid ink is specified.."],
+      0x01052A00 => ["Command Sequence Error", "The command is issued in bad order. Ex. Load Card is done when the card is in the printer."],
+      0x01052B00 => ["MG Data Error", "MG data from the host computer is invalid."],
+      0x01052C00 => ["IC Encoder not installed", "There is no specified IC Encoder."],
+      0x01052D00 => ["MG Encoder not installed", "There is no specified MG Encoder."],
+      0x0105FB00 => ["Invalid Download Data", "Download data from the host computer is invalid."],
+      0x01062800 => ["Medium Changed", "Printer was initialized by pressing RESET button."],
+      0x01062900 => ["Power On or Bus Device Reset Occurred", "Printer was initialized by turning on the printer power."],
+      0x0142A200 => ["Media Run Out", "End of retransfer film is detected."],
+      0x0142B200 => ["Ink Run Out", "End of ink ribbon is detected."],
+
+      0x02000006 => ["No Printer", "No printer found."],
+      0x09000002 => ["No More Printer", "No further printer found."],
+
+      -1 => ["Busy Port Manager", "CX Port Manager did not send command to the printer because of Printer’s condition.  This error never happens."],
+      -2 => ["Busy Target", "Card Printer rejected the command because it is on the way of moving the card."],
+      -3 => ["Busy Busy", "CX-320 Control DLL rejected the command because the command issued by other process is on the way of processing."],
+      -4 => ["Busy Target2", "Card Printer rejected the command because it is on the way of printing on the retransfer film."],
+      -5 => ["Busy Target3", "Card Printer rejected the command because of both _TARGET_BUSY1 and _TARGET_BUSY2."],
+    }
+
+    ErrorById.each do |id, tt|
+      name, text = tt
+      klname = name.gsub(/[^a-z0-9]/i, " ").gsub(/ +([a-z])/i){ $1.upcase }.strip
+      base_klass = case klname
+        when /^Busy/ then BusyError
+        else PrinterError
+      end
+      klass = Class.new(base_klass)
+      const_set(klname, klass)
+      tt << klass
+    end
+
+    def check_returncode(code)
+      return code if code==0
+      mc = -code
+      codes = [mc >> 24 & 0xff, mc >> 16 & 0xff, mc >> 8 & 0xff, mc & 0xff]
+      klname, text, klass = ErrorById[mc]
+
+      if klname
+        raise klass.new("CX320: %s (code %02x %02x %02x %02x)" % [text, *codes], code)
+      else
+        raise UnknownPrinterError.new("CX320: error %02x %02x %02x %02x" % codes, code)
+      end
+    end
+  end
+end

data/lib/libcx320/version.rb

@@ -0,0 +1,3 @@
+module LibCX320
+  VERSION = "0.1.5"
+end

data/lib/libcx320.rb

@@ -0,0 +1,9 @@
+require "libcx320/version"
+require "libcx320/error_handling"
+require "libcx320/cx320"
+
+module LibCX320
+  autoload :DeviceDll, "libcx320/device_dll"
+  autoload :DeviceUsb, "libcx320/device_usb"
+  autoload :DeviceSimu, "libcx320/device_simu"
+end

data/libcx320.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'libcx320/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "libcx320"
+  spec.version       = LibCX320::VERSION
+  spec.authors       = ["Lars Kanis"]
+  spec.email         = ["lars@greiz-reinsdorf.de"]
+  spec.summary       = %q{Driver for Retransfer Printer CX-320}
+  spec.description   = %q{Driver for Retransfer Printer CX-320. Usable per PCP05CT.DLL or LIBUSB.}
+  spec.homepage      = "https://github.com/larskanis/libcx320"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data.tar.gz.sig

@@ -0,0 +1,2 @@
+v��nqI�x}b����m�+P�sI�4܈i�e��A�W�N�U�����Y
�+{?.�2=����[Z9���n���Q�D���k�3�\��d�V��|
����N(G��U�D��j�4}ڀ��a"�Ct�@I�>s�
+��fQ
dg�
3��N���Er���짰�Ɔ����ƍz����*��Q"��c��h���f��U;�5����n�?~f��� �1�������c�:�������[`ucz5=�`p�UN��сV7dLKoPF�ɫC��	��rٙq^i�EL����C������RD�U$�G�[���IĽ������p�pl|�|
�0}T���=%M��jYn�Vm��פ���Q@%b�C�h���D�mr��GD���Y

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: libcx320
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- Lars Kanis
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIEBDCCAmygAwIBAgIBBDANBgkqhkiG9w0BAQsFADAoMSYwJAYDVQQDDB1sYXJz
+  L0RDPWdyZWl6LXJlaW5zZG9yZi9EQz1kZTAeFw0yNjAxMDUxMTE5MzRaFw0yNzAx
+  MDUxMTE5MzRaMCgxJjAkBgNVBAMMHWxhcnMvREM9Z3JlaXotcmVpbnNkb3JmL0RD
+  PWRlMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAwum6Y1KznfpzXOT/
+  mZgJTBbxZuuZF49Fq3K0WA67YBzNlDv95qzSp7V/7Ek3NCcnT7G+2kSuhNo1FhdN
+  eSDO/moYebZNAcu3iqLsuzuULXPLuoU0GsMnVMqV9DZPh7cQHE5EBZ7hlzDBK7k/
+  8nBMvR0mHo77kIkapHc26UzVq/G0nKLfDsIHXVylto3PjzOumjG6GhmFN4r3cP6e
+  SDfl1FSeRYVpt4kmQULz/zdSaOH3AjAq7PM2Z91iGwQvoUXMANH2v89OWjQO/NHe
+  JMNDFsmHK/6Ji4Kk48Z3TyscHQnipAID5GhS1oD21/WePdj7GhmbF5gBzkV5uepd
+  eJQPgWGwrQW/Z2oPjRuJrRofzWfrMWqbOahj9uth6WSxhNexUtbjk6P8emmXOJi5
+  chQPnWX+N3Gj+jjYxqTFdwT7Mj3pv1VHa+aNUbqSPpvJeDyxRIuo9hvzDaBHb/Cg
+  9qRVcm8a96n4t7y2lrX1oookY6bkBaxWOMtWlqIprq8JZXM9AgMBAAGjOTA3MAkG
+  A1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQ4h1tIyvdUWtMI739xMzTR
+  7EfMFzANBgkqhkiG9w0BAQsFAAOCAYEAg/1LuXN3X8xwHVnhRvmBCZYkNErko40y
+  juq/qPF9vkPGxLEGaeZF1rv/obTs5SgIGEUkWdRsOl3F6bQN4MYUFlN/n6rPx19g
+  CqUMkmRtuFD+9EFBI4twoF2IJS0pYr9tkjUq8mb0VXblvfbEEUf460BJmuBXZTc6
+  OoLQHxjhhqhKBoP4lHXg/OMK9dnGn8+5DoKcsyWQvqq/GdK8pi4E47M/egzw54Go
+  g+oeyGDsNKOQlnIA9gbyPpExD1+akJ4v88T8jOUnsOkhBBUkpSktC2QmEYIU5e9j
+  N7muw6O5Bz3CQuSWIEjj9mMUS2fEEfq2km6zO5vs5eD6TdFnt8AC/HlOrPaxGcUX
+  Hjw/K7ZTvZLEb4awRijdy4wx3OlL9FAyZPjYOh8TdJrLl076c7GyimAkgnc8BrL5
+  g1vGc759o2t3KNnlUg8VwqkhFJp4gCko1QO/8Io5hPQZOvJw8dmqNiiiHqaDupfl
+  CI4mk2K8yQa8xtQ/RmFZxYS5XbHhDJCw
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: Driver for Retransfer Printer CX-320. Usable per PCP05CT.DLL or LIBUSB.
+email:
+- lars@greiz-reinsdorf.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/libcx320.rb
+- lib/libcx320/c.rb
+- lib/libcx320/cx320.rb
+- lib/libcx320/device_dll.rb
+- lib/libcx320/device_simu.rb
+- lib/libcx320/device_usb.rb
+- lib/libcx320/error_handling.rb
+- lib/libcx320/version.rb
+- libcx320.gemspec
+homepage: https://github.com/larskanis/libcx320
+licenses:
+- MIT
+metadata: {}
+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: 4.0.16
+specification_version: 4
+summary: Driver for Retransfer Printer CX-320
+test_files: []