rbuspirate 0.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ea1e9f18b739184a2722b3dd7d8cc4c8d64830291fe9caa93099360ade5ab41e
+  data.tar.gz: e7ad361bd69818d82d73b1fb0942c184808428d835b66c894b70f1843fee4fa3
+SHA512:
+  metadata.gz: 67bb082b478a92a839d8d8f5c8d0806ada5944d82cb8edf7de25626890519b6ed3afeae18fb0280c40ba4b503ef1f615a40307d1fad888d58294587160079fc7
+  data.tar.gz: 8f066117c4100121d93ac477d1eea45f815a8e016651ad246e11e5fd81044553de5ada39080aa363323d399249b01d1caaaaaf39006b715bfa051826ff23a3ad

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rbuspirate.gemspec
+gemspec
+
+gem "pry", "~> 0.12.2"

data/Gemfile.lock

@@ -0,0 +1,28 @@
+PATH
+  remote: .
+  specs:
+    rbuspirate (0.2.3)
+      serialport (~> 1.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    method_source (0.9.2)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (10.5.0)
+    serialport (1.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  pry (~> 0.12.2)
+  rake (~> 10.0)
+  rbuspirate!
+
+BUNDLED WITH
+   2.1.4

data/README.md

@@ -0,0 +1,43 @@
+# Rbuspirate
+
+Better ruby driver for buspirate
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rbuspirate'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rbuspirate
+
+## Usage
+See examples/ dir
+
+## Status
+
+I2C: Full support  
+UART: Basic support (only bridge mode, no custom speed)  
+1WIRE: Full support  
+Windows not supported, contributions are welcomed  
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/sh7d/rbuspirate.
+
+## Todo
+* Documentation
+* Full uart support
+* SPI
+* Other protocols

data/Rakefile

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

data/bin/console

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'rbuspirate'
+require 'optparse'
+require 'pry'
+
+le_options = {}
+
+optparse = OptParse.new do |opts|
+  opts.on(
+    '-d device', '--device device', String, 'Path to buspirate device'
+  ) do |device|
+    dev_stat = File.stat(device).rdev rescue nil
+    raise 'Connect buspirate first' unless dev_stat
+    raise 'Device argument must be device' if dev_stat.zero?
+
+    le_options[:device] = device
+  end
+end
+optparse.parse!
+le_options.freeze
+if le_options[:device]
+  bp = SerialPort.new(le_options[:device], 115_200, 8, 1, SerialPort::NONE)
+  rs = Rbuspirate::Client.new(bp)
+
+  binding.pry
+else
+  puts optparse.to_s
+end

data/bin/setup

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

data/examples/i2c.rb

@@ -0,0 +1,37 @@
+require 'rbuspirate'
+
+bp = Rbuspirate::Client.new('/dev/buspirate')
+bp.enter_i2c
+# valid settings are :'5khz', :'50khz', :'100khz', :'400khz'
+bp.interface.speed = :'400khz'
+# default vaules are false
+bp.interface.configure_peripherals(
+  power: true, pullup: true, aux: false, cs: false
+)
+# you can see definet peripherals config via accesors
+puts "Power #{bp.interface.power ? 'enabled' : 'disabled'}"
+puts "Pull-up resitors #{bp.interface.pullup ? 'enabled' : 'disabled'}"
+# Frist argument is command
+# second expected data to read
+# succes_timeout specifies timeout to read data from device
+# allow_zerobyte: allows one single byte instead of expected data to read
+data = bp.interface.write_then_read(0xA1.chr, 4, succes_timeout: 5, allow_zerobyte: false)
+puts "First 4 bytes are #{data.unpack('H*').join}"
+
+# You can also acces raw mode
+# Block is optional
+bp.interface.send_start
+ack_array = bp.interface.bulk_write("\xA0\x00\x00\xDE\xAD".b, ack_timeout: 1, &method(:puts))
+bp.interface.send_stop
+puts ack_array
+
+# And read
+bp.interface.send_start
+bp.interface.bulk_write("\xA0\x00\x00".b)
+bp.interface.send_stop
+bp.interface.send_start
+bp.interface.bulk_write("\xA1".b)
+# default vaules are true for acks, and 1 for readbyte_timeout
+data = bp.interface.read(4, auto_ack: true, auto_nack: true, readbyte_timeout: 1)
+bp.interface.send_stop
+puts "First 4 bytes are: #{data.unpack('H*').join}"

data/examples/uart.rb

@@ -0,0 +1,29 @@
+require 'rbuspirate'
+
+bp = Rbuspirate::Client.new('/dev/buspirate')
+bp.enter_uart
+# set speed
+bp.interface.speed = 115_200
+# parity_data possible vaules are: :n8, :e8, :o8, :n9
+bp.interface.config_uart(
+  pin_out_33: true, stop_bits: 1, parity_data: :n8, rx_idle: true
+)
+# you can see defined settings via accesors
+puts "Pin out voltage #{bp.interface.pin_out_33 ? '3.3V' : '5V'}"
+# Enable power
+bp.interface.configure_peripherals(
+  power: false, pullup: false, aux: false, cs: false
+)
+# you can call to configure_peripherals like configure_peripherals(power: true)
+# rest of arguments will be in default state (false)
+# you can also see peripherals config state via accesors
+puts "Power #{bp.interface.power ? 'enabled' : 'disabled'}"
+# Bridge mode
+bp.interface.enter_bridge
+
+# raw port is exposed via port accesor
+port = bp.interface.port
+
+while (line = port.readline)
+  puts line
+end

data/lib/rbuspirate.rb

@@ -0,0 +1,107 @@
+require 'expect'
+require 'serialport'
+
+require 'rbuspirate/commands'
+require 'rbuspirate/responses'
+require 'rbuspirate/timeouts'
+require 'rbuspirate/interfaces/abstract'
+require 'rbuspirate/interfaces/i2c'
+require 'rbuspirate/interfaces/uart'
+require 'rbuspirate/interfaces/1wire'
+
+module Rbuspirate
+  class Client
+    def self.register_mode(
+      name_symbol,    switch_command,
+      wait_timeout,   enter_response,
+      interface_class
+    )
+      define_method("enter_#{name_symbol}".to_sym) do
+        switch_mode(
+          name_symbol,    switch_command,
+          wait_timeout,   enter_response,
+          interface_class
+        )
+      end
+    end
+
+    attr_reader :mode, :interface, :needs_reset
+    alias iface interface
+
+    def initialize(dvc, sync: true)
+      raise ArgumentError, 'Shitty arg' unless [SerialPort, String].include?(dvc.class)
+
+      if dvc.instance_of?(String)
+        raise 'Connect buspirate first' unless File.exist?(dvc)
+        raise 'Device argument must be device' if File.stat(dvc).rdev.zero?
+
+        dvc = SerialPort.new(dvc, 115_200, 8, 1, SerialPort::NONE)
+        dvc.flow_control = SerialPort::NONE
+      end
+      @le_port = dvc
+      @le_port.sync = true if sync
+      @needs_reset = false
+      reset_binary_mode
+    end
+
+    def reset_binary_mode
+      raise 'Device needs reset to change mode' if @needs_reset
+
+      20.times do
+        @le_port.putc(Commands::RESET_BITBANG)
+        resp = @le_port.expect(
+          Responses::BITBANG_MODE, Timeouts::BINARY_RESET
+        )
+
+        if resp
+          @interface = nil
+          @mode = :bitbang
+          return true
+        end
+      end
+
+      raise 'Enter to bitbang failied'
+    end
+    [
+      [
+        :i2c, Commands::I2C::ENTER,
+        Timeouts::I2C::ENTER, Responses::I2C::ENTER,
+        Interfaces::I2C
+      ],
+      [
+        :uart, Commands::UART::ENTER,
+        Timeouts::UART::ENTER, Responses::UART::ENTER,
+        Interfaces::UART
+      ],
+      [
+        :'1wire', Commands::LE1WIRE::ENTER,
+        Timeouts::LE1WIRE::ENTER, Responses::LE1WIRE::ENTER,
+        Interfaces::LE1WIRE
+      ]
+    ].each do |mode|
+      register_mode(*mode)
+    end
+
+    private
+
+    def switch_mode(
+      name_symbol,    switch_command,
+      wait_timeout,   enter_response,
+      interface_class
+    )
+      raise 'Device needs reset to change mode' if @needs_reset
+      reset_binary_mode
+      @le_port.write(switch_command.chr)
+      resp = @le_port.expect(
+        enter_response, wait_timeout
+      )
+      if resp
+        @mode = name_symbol
+        @interface = interface_class.new(@le_port, self)
+        return true
+      end
+
+      raise "Switch to #{name_symbol.to_s.upcase} failied"
+    end
+  end
+end

data/lib/rbuspirate/commands.rb

@@ -0,0 +1,82 @@
+# Encoding: binary
+# frozen_string_literal: true
+
+module Rbuspirate
+  module Commands
+    RESET_BITBANG = 0b00000000
+    CONF_PER = 0b01000000
+
+    module Config
+      module Peripherals
+        POWER = 0b00001000
+        PULLUP = 0b00000100
+        AUX = 0b00000010
+        CS = 0b00000001
+      end
+    end
+
+    module LE1WIRE
+      ENTER = 0b00000100
+      RESET = 0b00000010
+
+      module IO
+        READ = 0b00000100
+        WRITE = 0b00010000
+      end
+    end
+
+    module I2C
+      ENTER = 0b00000010
+      PREPARE_WRITE = 0b00010000
+      READBYTE = 0b00000100
+      WRITE_THEN_READ = 0x8
+
+      module Config
+        module Speed
+          S5KHZ = 0b01100000
+          S50KHZ = 0b01100001
+          S100KHZ = 0b01100010
+          S400KHZ = 0b01100011
+        end
+      end
+
+      module Flow
+        START = 0b00000010
+        STOP = 0b00000011
+        ACK = 0b00000110
+        NACK = 0b00000111
+      end
+    end
+
+    module UART
+      ENTER = 0b00000011
+      START_BRIDGE = 0b00001111
+
+      module Config
+        CONF_UART = 0b10000000
+
+        module Speed
+          S300 = 0b01100000
+          S1200 = 0b01100001
+          S2400 = 0b01100010
+          S4800 = 0b01100011
+          S9600 = 0b01100100
+          S19200 = 0b01100101
+          S31250 = 0b01100110
+          S38400 = 0b01100111
+          S57600 = 0b01101000
+          S115200 = 0b01101010
+        end
+
+        module UartConf
+          PIN_OUT_33 = 0b00010000
+          DAT_PARITY_8E = 0b00000100
+          DAT_PARITY_80 = 0b00001000
+          DAT_PARITY_9N = 0b00001100
+          STOP_BIT_2 = 0b00000010
+          DISABLE_RX_IDLE = 0b00000001
+        end
+      end
+    end
+  end
+end

data/lib/rbuspirate/helpers.rb

@@ -0,0 +1,16 @@
+# Encoding: binary
+# frozen_string_literal: true
+
+module Rbuspirate
+  module Helpers
+    private
+
+    def simplex_command(command, tout, ex_message)
+      @le_port.write(command.chr)
+      resp = @le_port.expect(Responses::SUCCESS, tout)
+      return true if resp
+
+      raise ex_message
+    end
+  end
+end

data/lib/rbuspirate/interfaces/1wire.rb

@@ -0,0 +1,50 @@
+# Encoding: binary
+# frozen_string_literal: true
+
+module Rbuspirate
+  module Interfaces
+    class LE1WIRE < Abstract
+      def initialize(serial, bup)
+        raise 'Bus pirate must be in 1wire mode' unless bup.mode == :'1wire'
+        @le_port = serial
+      end
+
+      def reset
+        simplex_command(
+          Commands::LE1WIRE::RESET,
+          Timeouts::LE1WIRE::RESET,
+          'Unable to reset external device (comm timeout/no device)'
+        )
+      end
+
+      def write(data, write_slice_timeout: Timeouts::LE1WIRE::WRITE)
+        !(data.is_a?(String) && !data.empty?) &&
+          raise(ArgumentError, 'data must be non empty String instance')
+
+        data = StringIO.new(data)
+        while (slice = data.read(16))
+          command = Commands::LE1WIRE::IO::WRITE | slice.bytesize - 1
+          simplex_command(
+            command, write_slice_timeout, 'Prepare slice write timeout'
+          )
+          @le_port.write(slice)
+          res = @le_port.expect(Responses::SUCCESS, write_slice_timeout)
+          raise 'Write timeout' unless res
+        end
+        true
+      end
+
+      def read(bytes = 1, readbyte_timeout: Timeouts::LE1WIRE::READ)
+        result = ''.dup.b
+        bytes.times do
+          @le_port.write(Commands::LE1WIRE::IO::READ.chr)
+          Timeout.timeout(readbyte_timeout) do
+            result << @le_port.read(1)
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/rbuspirate/interfaces/abstract.rb

@@ -0,0 +1,40 @@
+# Encoding: binary
+# frozen_string_literal: true
+
+module Rbuspirate
+  module Interfaces
+    class Abstract
+      def configure_peripherals(
+        power: false, pullup: false, aux: false, cs: false
+      )
+        [power, pullup, aux, cs].map(&:class).each do |cls|
+          raise ArgumentError, 'All args must be true or false' unless [FalseClass, TrueClass].include?(cls)
+        end
+
+        bit_config = Commands::CONF_PER
+        bit_config |= Commands::Config::Peripherals::POWER if power
+        bit_config |= Commands::Config::Peripherals::PULLUP if pullup
+        bit_config |= Commands::Config::Peripherals::AUX if aux
+        bit_config |= Commands::Config::Peripherals::CS if cs
+
+        simplex_command(
+          bit_config,
+          Timeouts::SUCCESS,
+          'Unable to confgure peripherals'
+        )
+       @power, @pullup, @aux, @cs = power, pullup, aux, cs
+      end
+
+      protected
+
+      def simplex_command(command, tout, ex_message)
+        command = command.chr if command.instance_of?(Integer)
+        @le_port.write(command.chr)
+        resp = @le_port.expect(Responses::SUCCESS, tout)
+        return true if resp
+
+        raise ex_message
+      end
+    end
+  end
+end

data/lib/rbuspirate/interfaces/i2c.rb

@@ -0,0 +1,153 @@
+# Encoding: binary
+# frozen_string_literal: true
+
+require 'timeout'
+
+module Rbuspirate
+  module Interfaces
+    class I2C < Abstract
+      attr_reader :speed, :power, :pullup, :aux, :cs
+
+      def initialize(serial, bup)
+        raise 'Bus pirate must be in i2c mode' unless bup.mode == :i2c
+
+        @le_port = serial
+        set_speed(:'400khz')
+      end
+
+      def speed=(le_speed)
+        set_speed(le_speed)
+      end
+
+      def send_start
+        simplex_command(
+          Commands::I2C::Flow::START,
+          Timeouts::I2C::STARTSTOP,
+          'Unable to sent start bit'
+        )
+      end
+
+      def send_stop
+        simplex_command(
+          Commands::I2C::Flow::STOP,
+          Timeouts::I2C::STARTSTOP,
+          'Unable to sent stop bit'
+        )
+      end
+
+      def send_ack
+        simplex_command(
+          Commands::I2C::Flow::ACK,
+          Timeouts::I2C::ACKNACK,
+          'Unable to sent ack'
+        )
+      end
+
+      def send_nack
+        simplex_command(
+          Commands::I2C::Flow::NACK,
+          Timeouts::I2C::ACKNACK,
+          'Unable to sent nack'
+        )
+      end
+
+      def read(bytes = 1, auto_ack: true, auto_nack: true, readbyte_timeout: Timeouts::I2C::READ)
+        result = ''.dup.b
+        bytes.times do |t|
+          @le_port.write(Commands::I2C::READBYTE.chr)
+          Timeout.timeout(readbyte_timeout) do
+            result << @le_port.read(1)
+          end
+          send_ack if auto_ack && t + 1 != bytes
+          send_nack if auto_nack && t + 1 == bytes
+        end
+        result
+      end
+
+      def bulk_write(data, ack_timeout: Timeouts::I2C::SLAVE_ACKNACK)
+        raise ArgumentError, 'data must be String instance' unless data.instance_of?(String)
+
+        if !data.instance_of?(String) || data.instance_of?(String) && data.empty?
+          raise ArgumentError, 'Bad data argument'
+        end
+        raise ArgumentError, 'Data is too long' if data.bytesize > 16
+
+        bit_bulk_write = Commands::I2C::PREPARE_WRITE | data.bytesize - 1
+        simplex_command(
+          bit_bulk_write.chr,
+          Timeouts::I2C::PREPARE_WRITE,
+          'Unable to prepare write mode'
+        )
+        ack_array = []
+        data.each_byte do |data_byte|
+          @le_port.write(data_byte.chr)
+          Timeout.timeout(ack_timeout) do
+            ack_array << case @le_port.read(1).ord
+                         when 0
+                           :ack
+                         when 1
+                           :nack
+                         else
+                           raise 'Unknown bytewrite response'
+                         end
+            yield(ack_array.last) if block_given?
+          end
+        end
+        ack_array.freeze
+      end
+
+      def write_then_read(
+        data, expected_bytes = 0,
+        succes_timeout: Timeouts::I2C::WRITE_THEN_READ_S,
+        allow_zerobyte: false
+      )
+        raise ArgumentError, 'Bad data type' unless data.instance_of?(String)
+        raise ArgumentError, 'Data is too long' if data.bytesize > 4096
+        raise ArgumentError, 'Bad expected_bytes type' unless expected_bytes.instance_of?(Integer)
+        raise ArgumentError, 'Bad expected_bytes value' if expected_bytes.negative? || expected_bytes > 4096
+
+        binary_command = Commands::I2C::WRITE_THEN_READ.chr +
+                         [data.bytesize, expected_bytes].pack('S>S>') +
+                         data
+        @le_port.write(binary_command)
+        result = nil
+        # So fucking ugly
+        begin
+          Timeout.timeout(succes_timeout) do
+            result = @le_port.read(1)
+          end
+        rescue Timeout::Error
+          return false
+        end
+        return false if allow_zerobyte && result.ord.zero?
+        raise 'Write failed' if result.ord.zero?
+        if expected_bytes != 0
+          Timeout.timeout(Timeouts::I2C::WRITE_THEN_READ_D) do
+            result = @le_port.read(expected_bytes)
+          end
+          result
+        else
+          true
+        end
+      end
+      private
+      def set_speed(le_speed)
+        bit_speed = case le_speed.to_sym
+                    when :'5khz'
+                      Commands::I2C::Config::Speed::S5KHZ
+                    when :'50khz'
+                      Commands::I2C::Config::Speed::S50KHZ
+                    when :'100khz'
+                      Commands::I2C::Config::Speed::S100KHZ
+                    when :'400khz'
+                      Commands::I2C::Config::Speed::S400KHZ
+                    else
+                      raise ArgumentError, 'Bad speed argument'
+                    end
+
+        simplex_command(bit_speed, Timeouts::SUCCESS, 'Unable to set speed')
+        @speed = le_speed
+      end
+    end
+  end
+end

data/lib/rbuspirate/interfaces/uart.rb

@@ -0,0 +1,110 @@
+# Encoding: binary
+# frozen_string_literal: true
+
+require 'timeout'
+
+module Rbuspirate
+  module Interfaces
+    class UART < Abstract
+      attr_reader :bridge, :speed, :power, :pullup, :aux, :cs,
+                  :pin_out_33, :parity_data, :stop_bits, :rx_idle,
+                  :port
+
+      def initialize(serial, bup)
+        raise 'Bus pirate must be in uart mode' unless bup.mode == :uart
+
+        @bridge = false
+        @bup = bup
+        @le_port = serial
+      end
+
+      def configure_peripherals(...)
+        raise 'Device needs reset in order to reconfigure it' if @bridge
+
+        super
+      end
+
+      def speed=(le_speed)
+        raise 'Device needs reset in order to reconfigure it' if @bridge
+
+        bit_speed = case le_speed
+                    when 300
+                      Commands::UART::Config::Speed::S300
+                    when 1200
+                      Commands::UART::Config::Speed::S1200
+                    when 2400
+                      Commands::UART::Config::Speed::S2400
+                    when 4800
+                      Commands::UART::Config::Speed::S4800
+                    when 9600
+                      Commands::UART::Config::Speed::S9600
+                    when 19_200
+                      Commands::UART::Config::Speed::S19200
+                    when 31_250
+                      Commands::UART::Config::Speed::S31250
+                    when 38_400
+                      Commands::UART::Config::Speed::S38400
+                    when 57_600
+                      Commands::UART::Config::Speed::S57600
+                    when 115_200
+                      Commands::UART::Config::Speed::S115200
+                    else
+                      raise ArgumentError, 'Unsupported speed'
+                    end
+
+        simplex_command(bit_speed, Timeouts::SUCCESS, 'Unable to set speed')
+        @speed = bit_speed
+      end
+
+      def config_uart(
+        pin_out_33: false, parity_data: :n8, stop_bits: 1, rx_idle: true
+      )
+        raise 'Device needs reset in order to reconfigure it' if @bridge
+
+        raise ArgumentError, 'Pin out should be false or true' unless [true, false].include?(pin_out_33)
+        raise ArgumentError, 'Unknown praity and databits mode' unless [:n8, :e8, :o8, :n9].include?(parity_data)
+        raise ArgumentError, 'Unknown stop bits mode' unless [1, 2].include?(stop_bits)
+        raise ArgumentError, 'Rx idle should be false or true' unless [true, false].include?(rx_idle)
+
+        bit_conf_uart = Commands::UART::Config::CONF_UART
+
+        bit_conf_uart |= Commands::UART::Config::UartConf::PIN_OUT_33 if pin_out_33
+        bit_conf_uart |= case parity_data
+                         when :e8
+                           Commands::UART::Config::UartConf::DAT_PARITY_8E
+                         when :o8
+                           Commands::UART::Config::UartConf::DAT_PARITY_8O
+                         when :n9
+                           Commands::UART::Config::UartConf::DAT_PARITY_9N
+                         else
+                           0
+                         end
+        bit_conf_uart |= Commands::UART::Config::UartConf::STOP_BIT_2 if stop_bits == 2
+        bit_conf_uart |= Commands::UART::Config::UartConf::DISABLE_RX_IDLE unless rx_idle
+
+        simplex_command(bit_conf_uart, Timeouts::SUCCESS, 'Unable to config uart')
+
+        @pin_out_33, @parity_data, @stop_bits, @rx_idle = pin_out_33, parity_data, stop_bits, rx_idle
+      end
+
+      def enter_bridge
+        return @bridge if @bridge
+
+        @le_port.write(Commands::UART::START_BRIDGE.chr)
+        @bridge = true
+        @bup.instance_variable_set(:@needs_reset, true)
+        @port = @le_port
+      end
+
+      def read(bytes = 0)
+        raise 'Enter to bridge mode first' unless @bridge
+        bytes.positive? ? @le_port.read(bytes) : @le_port.read
+      end
+
+      def write(data)
+        raise 'Enter to bridge mode first' unless @bridge
+        @le_port.write(data.to_s.b)
+      end
+    end
+  end
+end

data/lib/rbuspirate/responses.rb

@@ -0,0 +1,21 @@
+# Encoding: binary
+# frozen_string_literal: true
+
+module Rbuspirate
+  module Responses
+    BITBANG_MODE = 'BBIO1'
+    SUCCESS = 0x01.chr
+
+    module LE1WIRE
+      ENTER = '1W01'
+    end
+
+    module I2C
+      ENTER = 'I2C1'
+    end
+
+    module UART
+      ENTER = 'ART1'
+    end
+  end
+end

data/lib/rbuspirate/timeouts.rb

@@ -0,0 +1,31 @@
+# Encoding: binary
+# frozen_string_literal: true
+
+module Rbuspirate
+  module Timeouts
+    BINARY_RESET = 0.05
+    SUCCESS = 0.1
+
+    module LE1WIRE
+      ENTER = 0.2
+      RESET = 0.5
+      WRITE = 1
+      READ = 1
+    end
+
+    module I2C
+      ENTER = 0.2
+      STARTSTOP = 0.5
+      PREPARE_WRITE = 0.1
+      ACKNACK = 0.3
+      READ = 1
+      SLAVE_ACKNACK = 0.5
+      WRITE_THEN_READ_S = 5
+      WRITE_THEN_READ_D = 5
+    end
+
+    module UART
+      ENTER = 0.2
+    end
+  end
+end

data/lib/rbuspirate/version.rb

@@ -0,0 +1,3 @@
+module Rbuspirate
+  VERSION = '0.2.3'
+end

data/rbuspirate.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rbuspirate/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rbuspirate"
+  spec.version       = Rbuspirate::VERSION
+  spec.authors       = ["sh7d"]
+  spec.email         = ["sh7d@sh7d"]
+
+  spec.summary       = %q{Ruby better buspirate interface}
+  spec.description   = %q{Simple buspirate ruby interface}
+  spec.homepage      = "https://github.com/sh7d/rbuspirate"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib'] + Dir.glob('lib/**').select(&File.method(:directory?))
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry", "~> 0.12"
+  spec.add_dependency "serialport", "~> 1.3"
+end
+

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: rbuspirate
+version: !ruby/object:Gem::Version
+  version: 0.2.3
+platform: ruby
+authors:
+- sh7d
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: serialport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Simple buspirate ruby interface
+email:
+- sh7d@sh7d
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/i2c.rb
+- examples/uart.rb
+- lib/rbuspirate.rb
+- lib/rbuspirate/commands.rb
+- lib/rbuspirate/helpers.rb
+- lib/rbuspirate/interfaces/1wire.rb
+- lib/rbuspirate/interfaces/abstract.rb
+- lib/rbuspirate/interfaces/i2c.rb
+- lib/rbuspirate/interfaces/uart.rb
+- lib/rbuspirate/responses.rb
+- lib/rbuspirate/timeouts.rb
+- lib/rbuspirate/version.rb
+- rbuspirate.gemspec
+homepage: https://github.com/sh7d/rbuspirate
+licenses: []
+metadata:
+  homepage_uri: https://github.com/sh7d/rbuspirate
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib/rbuspirate
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Ruby better buspirate interface
+test_files: []