spi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b7194309444e270662ed8d5420ac8ce84cb0e175
+  data.tar.gz: 1b636b4d38ad56b04650405e158e5eca8726daa7
+SHA512:
+  metadata.gz: 970ec16d5eed918ecaccbd732be353836f6ab394e96f2925044f82f4aa80c0c3000cfab629d38675060268604230b20dce72237f66a2c37d4bdecbf8c6abe0be
+  data.tar.gz: 0794eb9034851daaeb91ebce74866cd582e8c603eaffa3d035d88ecea222a686c8aaf92242734ed0e62aed7eaae98cd6effb7a529b79dae3d8c4a6b1a61d115a

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2017 Mike Axford
+
+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,67 @@
+# SPI
+
+This gem aims to provide a Unified method of talking to SPI devices on a variety of hardware. This is mainly aimed at a range of Small Board Computers (SBCs) such as the Raspberry Pi and C.H.I.P. computers.
+
+Currently only the Linux spidev kernel interface is implimented however the code is designed to make adding other drivers a simple process. It should then be possible to choose the correct driver for the hardware without having to re-write code.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'spi'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install spi
+
+## Usage
+
+You may need to enable the SPI device on your hardware and/or load the kernel module.
+On the Raspberry Pi SPI can be enabled through raspi-cofig
+On the C.H.I.P. SPI can be loaded by importing the SPI DTB
+
+After doing this you should find one or more devices in /dev
+```bash
+user@device:~ $ ls /dev/spi*
+/dev/spidev32766.0
+```
+
+To use the default (SPIdev) driver you can specify
+```ruby
+require "bundler/setup"
+require "spi"
+s=SPI.new(device: '/dev/spidev32766.0')
+s.speed=500000
+s.xfer(txdata: [0x10,0x00])
+```
+Currently SPIdev is the only driver.
+
+
+Simple Testing of just the SPIdev Driver with an RFM69
+```ruby
+require "bundler/setup"
+require "spi"
+require 'spi/driver/spidev'
+s=SPI::Driver::SPIdev.new(device: '/dev/spidev32766.0')
+s.speed=500000
+s.xfer(txdata: [0x10,0x00])
+```
+This should result in a 2 byte array with the 2nd value reporting 36 (0x24)
+
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/spi.
+

data/Rakefile

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

data/lib/spi.rb

@@ -0,0 +1,31 @@
+require "spi/version"
+require "spi/driver"
+
+class SPI
+
+  class SPIException < Exception; end
+
+  attr_reader :driver
+
+  def initialize (args={})
+
+    if args[:driver].nil?
+      require "spi/driver/spidev"
+      @device = args[:device] or raise SPIException, "args[:device] required"
+      @driver=SPI::Driver::SPIdev.new(device: '/dev/spidev32766.0')
+    end
+
+    def speed
+      @driver.speed
+    end
+
+    def speed=(speed)
+      @driver.speed=speed
+    end
+
+    def xfer(txdata: [], length: 0)
+      @driver.xfer(txdata: txdata, length: length)
+    end
+
+  end
+end

data/lib/spi/driver.rb

@@ -0,0 +1,12 @@
+class SPI
+  module Driver
+    # Abstract class for I2CDevice::Driver
+    class Base
+      include SPI::Driver
+    end
+
+    def xfer
+      raise NotImplementedError, "xfer needs to be defined per Driver Library"
+    end
+  end
+end

data/lib/spi/driver/spidev.rb

@@ -0,0 +1,177 @@
+require 'spi'
+
+class SPI
+  module Driver
+    class SPIdev < SPI::Driver::Base
+      attr_reader :mode
+      attr_reader :bits
+      attr_reader :speed
+
+      def initialize(args={})
+        raise SPIException, "No Device specified" if args[:device].nil?
+        raise SPIException, "Device #{args[:device]} not found" unless File.exists?(args[:device])
+        puts "Using Device #{args[:device]}"
+        @device = File.open(args[:device])
+        @mode=getMode
+        @bits=getBits
+        @speed=getSpeed
+      end
+
+      def mode=(mode)
+        @device.ioctl(SPI_IOC_WR_MODE(), mode.pack('C'));
+        @mode=getMode
+      end
+
+      def bits=(bits)
+        @device.ioctl(SPI_IOC_WR_BITS_PER_WORD(), bits.pack('C'))
+        @bits=getBits
+      end
+
+      def speed=(speed)
+        @device.ioctl(SPI_IOC_WR_MAX_SPEED_HZ(),[speed].pack('L'))
+        @speed=getSpeed
+      end
+
+      # TODO accessors for SPI_IOC_WR_LSB_FIRST and SPI_IOC_WR_MODE32
+
+
+      # By the length used will always be the greater of txdata.size and length.
+      # rxdata will be sized according to that maximum and txdata grown if needed
+      def xfer(txdata: [], length: 0)
+        # Ensure tx and rx buffers are the same size
+        length = txdata.size if txdata.size > length
+        txdata += (Array.new(length-txdata.size) {0}) if length > txdata.size
+        rxdata  = (Array.new(length) { 0 })
+        
+        # TODO Use the bitstruct gem ?
+        # https://rubygems.org/gems/bit-struct/versions/0.15.0
+        # Or create a class to wrap access and pack/unpack
+
+        txdata_pack       = txdata.pack('C*')     # __u64 (pointer to data)
+        rxdata_pack       = rxdata.pack('C*')     # __u64 (pointer to data)
+
+        # length                                  # __u32
+        speed             = 0                     # __u32
+
+        delay_usecs       = 0                     # __u16
+        bits_per_word     = 0                     # __u8
+        cs_change         = 0                     # __u8
+        tx_nbits          = 0                     # __u8
+        rx_nbits          = 0                     # __u8
+        pad               = 0                     # __u16
+
+        txdata_p = [txdata_pack].pack('P').unpack('L!')[0] # 64bit pointer to txdata
+        rxdata_p = [rxdata_pack].pack('P').unpack('L!')[0] # 64bit pointer to rxdata
+
+        # We might need to do something special with the txdata and rxdata pointers to make them 64 bit
+        data = [txdata_p, rxdata_p, length, speed, delay_usecs, bits_per_word, cs_change, tx_nbits, rx_nbits, pad].pack('QQLLSCCCCS')
+
+        # We're only going to handle one message at a time for now
+        @device.ioctl(SPI_IOC_MESSAGE(1),data)
+
+        return rxdata_pack.unpack('C*')
+    
+      end
+
+    private
+      # TODO It might be good to generalize these functions, Maybe make a IOCTL class?
+      def getMode
+        data=[0].pack('C')
+        @device.ioctl(SPI_IOC_RD_MODE(), data);
+        return data.unpack('C')[0]
+      end
+
+      def getBits
+        data=[0].pack('C')
+        @device.ioctl(SPI_IOC_RD_BITS_PER_WORD(), data);
+        return data.unpack('C')[0]
+      end
+
+      def getSpeed
+        data=[0].pack('L')
+        @device.ioctl(SPI_IOC_RD_MAX_SPEED_HZ(),data)
+        return data.unpack('L')[0]
+      end
+
+
+      # Functions and Constants based on /usr/include/asm-generic/ioctl.h
+      IOC_NONE    = 0x00
+      IOC_WRITE   = 0x01
+      IOC_READ    = 0x02
+
+      def _IOC(dir, type, nr, size)
+        out=0
+        out += dir  << (14 + 8 + 8) # 2 bits
+        out += size << (     8 + 8) # 14 bits
+        out += type << (         8) # 8 bits
+        out += nr                   # 8 bits
+        return out
+      end
+
+      def _IO(type,nr);         _IOC(IOC_NONE,            type, nr, 0); end
+      def _IOR(type,nr,size);   _IOC(IOC_READ,            type, nr, size); end
+      def _IOW(type,nr,size);   _IOC(IOC_WRITE,           type, nr, size); end
+      def _IOWR(type,nr,size);  _IOC(IOC_READ |IOC_WRITE, type, nr, size); end
+      
+      # Functions and Constants based on /usr/include/linux/spi/spidev.h
+      SPI_CPHA       = 0x01
+      SPI_CPOL       = 0x02
+
+      MODE0     = (0|0)
+      MODE1     = (0|SPI_CPHA)
+      MODE2     = (SPI_CPOL|0)
+      MODE3     = (SPI_CPOL|SPI_CPHA)
+
+      SPI_CS_HIGH    = 0x04
+      SPI_LSB_FIRST  = 0x08
+      SPI_3WIRE      = 0x10
+      SPI_LOOP       = 0x20
+      SPI_NO_CS      = 0x40
+      SPI_READY      = 0x80
+      SPI_TX_DUAL    = 0x100
+      SPI_TX_QUAD    = 0x200
+      SPI_RX_DUAL    = 0x400
+      SPI_RX_QUAD    = 0x800
+
+      SPI_IOC_MAGIC   = 'k'.ord
+
+      # SPI Definitions based on /usr/include/linux/spi/spidev.h
+      # TODO we could also determine these as constants
+      # /* Read / Write of SPI mode (SPI_MODE_0..SPI_MODE_3) (limited to 8 bits) */
+      def SPI_IOC_RD_MODE;            _IOR(SPI_IOC_MAGIC, 1, 1); end
+      def SPI_IOC_WR_MODE;            _IOW(SPI_IOC_MAGIC, 1, 1); end
+
+      # /* Read / Write SPI bit justification */
+      def SPI_IOC_RD_LSB_FIRST;       _IOR(SPI_IOC_MAGIC, 2, 1); end
+      def SPI_IOC_WR_LSB_FIRST;       _IOW(SPI_IOC_MAGIC, 2, 1); end
+
+      # /* Read / Write SPI device word length (1..N) */
+      def SPI_IOC_RD_BITS_PER_WORD;   _IOR(SPI_IOC_MAGIC, 3, 1); end
+      def SPI_IOC_WR_BITS_PER_WORD;   _IOW(SPI_IOC_MAGIC, 3, 1); end
+
+      # /* Read / Write SPI device default max speed hz */
+      def SPI_IOC_RD_MAX_SPEED_HZ;    _IOR(SPI_IOC_MAGIC, 4, 4); end
+      def SPI_IOC_WR_MAX_SPEED_HZ;    _IOW(SPI_IOC_MAGIC, 4, 4); end
+
+      # /* Read / Write of the SPI mode field */
+      def SPI_IOC_RD_MODE32;          _IOR(SPI_IOC_MAGIC, 5, 4); end
+      def SPI_IOC_WR_MODE32;          _IOW(SPI_IOC_MAGIC, 5, 4); end
+
+      # If n * sizeof(spi_ioc_transfer) > 1 << _IOC_SIZEBITS we should return 0 instead
+      # In other words, I think the limit is the number of 32byte array we can fit in a 14 bit number
+      # See the relevant #define
+      def SPI_IOC_MESSAGE(n);         _IOW(SPI_IOC_MAGIC, 0, n*32); end
+    end
+  end
+end
+
+
+__END__
+  class SPIException < Exception ; end
+  class SPINoDevice < SPIException ; end
+
+
+NB: Before 3.15 __u32 and tx_nbits/rx_nbits didn't exist. Some distros seem to have the old header even on newer kernels
+
+
+

data/lib/spi/version.rb

@@ -0,0 +1,3 @@
+class SPI
+  VERSION = "0.1.0"
+end

data/spi.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'spi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "spi"
+  spec.version       = SPI::VERSION
+  spec.authors       = ["Mike Axford"]
+  spec.email         = ["mike@m1ari.co.uk"]
+
+  spec.summary       = %q{SPI access library }
+  spec.description   = %q{Module for configuring and communicating with devices on an SPI device, useful for various Small Board Computers such as RaspberryPi and C.H.I.P.}
+  spec.homepage      = "https://github.com/m1ari/ruby-spi"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: spi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mike Axford
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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: Module for configuring and communicating with devices on an SPI device,
+  useful for various Small Board Computers such as RaspberryPi and C.H.I.P.
+email:
+- mike@m1ari.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/spi.rb
+- lib/spi/driver.rb
+- lib/spi/driver/spidev.rb
+- lib/spi/version.rb
+- spi.gemspec
+homepage: https://github.com/m1ari/ruby-spi
+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.2.2
+signing_key: 
+specification_version: 4
+summary: SPI access library
+test_files: []