nrf24l01-ruby 0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 80a9154047d11cb58a2a2da3656ad3ad2c56199a
+  data.tar.gz: f1ba069e70574c42536902817ce1fcdb28b66c55
+SHA512:
+  metadata.gz: b361d65c676843f806d9dd6fc2f5acf61c9f19a9cd338eb80203a60530e15415d834bd05b9232c024c23a7941bcc64871daa1ba9c6f02bf6f75fef05ae7f3f9e
+  data.tar.gz: 68f63fa0d582514e17fdb317018236d21d0417e5ddfb33a3e78970a67409e701ef600bc70caf099ed22d952910f5f478178f030c0a1895e7453069b99480296a

data/.gitignore

@@ -0,0 +1,10 @@
+/.idea/*
+/.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 nrf24-ruby.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Rogier Lodewijks
+
+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,98 @@
+# nRF24 lib for Ruby
+
+nrf24-ruby is a pure Ruby library for controlling the ubiquitous nRF24l01(+) radio module. Currently primary target is
+the Raspberry Pi, but it shouldn't be too hard to port to a different platform (supporting SPI).
+ 
+No webserver, no message bus, no frills, yet a fully functional lib written in clear Ruby. (If you're in need of frills,
+bells, whistles and the like. This library gem works merrily together with all kinds of whistle implementing gems :smile:)   
+
+This gem was based on the [C++ RF24 library by tmrh20](https://github.com/TMRh20/RF24). I made the Ruby implementation
+mostly because wrapping C++ from Ruby sucks donkey balls.  
+
+## Installing
+Currently there's only one hardware driver included, which relies on the bcm2835 gem that wraps the [bcm2835 C library](http://www.airspayce.com/mikem/bcm2835). Therefore we need
+this C lib installed on our system.
+
+Build the lib
+ 
+    wget http://www.airspayce.com/mikem/bcm2835/bcm2835-1.49.tar.gz
+    tar zxvf bcm2835-1.49.tar.gz
+    cd bcm2835-1.49
+    ./configure
+    make
+    sudo make check
+    
+Make the shared library (.so file) and copy into the correct location
+    
+    cd src
+    gcc -shared -o libbcm2835.so bcm2835.o
+    sudo cp libbcm2835.so /usr/local/lib
+   
+_In case you don't feel like building the lib yourself, it's included in /binlib at your convenience._   
+
+**Caveat:** currently we're calling directly into the BCM2835's protected memory space, so we need to run as root.
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nrf24-ruby'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nrf24-ruby
+
+ 
+
+## Examples
+
+```ruby
+require 'nrf24-ruby'
+```
+
+The lib may be called using a block
+
+```ruby
+NRF24.begin {
+
+  set_channel 23
+  
+  print_regs
+
+  open_reading_pipe 1, [65, 65, 65, 65, 65]
+  
+  start_listening
+
+  loop do
+    p read if data_available?
+    sleep 0.01
+  end
+
+}
+``` 
+Or use the plain old instance based approach
+
+```ruby
+nrf = NRF24.new(channel: 0x4c)
+
+nrf.rf_setup :rate_250kbps, :max_power
+
+address = 'AAAAA'.unpack('c*')
+nrf.open_reading_pipe 1, address
+
+nrf.start_listening
+
+loop do
+  if pipe = nrf.data_available?
+    puts "data on pipe #{pipe}, fifo flags: #{nrf.fifo_flags}"
+    data  = nrf.read
+    p data
+  end
+
+  sleep 0.1 # Currently interrupt handling is not supported on Raspberry Pi, so we need to poll for new data
+end
+```

data/example/nrf24_listening_example.rb

@@ -0,0 +1,51 @@
+require 'msgpack'
+require 'nrf24-ruby'
+
+def with_block
+
+  NRF24.begin(channel: 85) {
+    puts "setting channel to #{ch = rand 125}"
+    # ch=85
+    # set_channel ch
+    print_regs
+
+    rf_setup :rate_250kbps, :max_power
+    open_reading_pipe 1, 'AAAAA'.unpack('c*')
+    start_listening
+
+    loop do
+      if data_available?
+        p read
+        puts "bytes received: #{read.count}"
+      end
+    end
+
+  }
+end
+
+def classic
+  nrf = NRF24.new channel: 85
+
+  nrf.rf_setup :rate_250kbps, :max_power
+
+  address = 'AAAAA'.unpack('c*')
+  nrf.open_reading_pipe 1, address
+
+  nrf.start_listening
+
+  nrf.print_regs
+  nrf.flush_rx
+
+  loop do
+    if pipe = nrf.data_available?
+      puts "Got data on pipe #{pipe}, FIFO flags: #{nrf.fifo_flags}"
+      data  = nrf.read
+      p data
+    end
+
+    sleep 0.1
+  end
+
+end
+
+classic

data/lib/nrf24-ruby.rb

@@ -0,0 +1,4 @@
+require 'nrf24/version'
+require 'nrf24/constants'
+require 'nrf24/nrf24-ruby'
+require 'nrf24/bcm2835_driver'

data/lib/nrf24/bcm2835_driver.rb

@@ -0,0 +1,31 @@
+require 'bcm2835'
+
+class NRF24
+  module Bcm2835Driver
+
+    def init_io
+      @spi = Bcm2835::SPI.begin
+      spi.clock Bcm2835::SPI::CLOCK_DIVIDER_128
+      spi.bit_order(Bcm2835::SPI::MSBFIRST)
+      Bcm2835::GPIO.output cepin
+      Bcm2835::GPIO.output csnpin
+    end
+
+    def ce_high
+      Bcm2835::GPIO.set cepin
+    end
+
+    def ce_low
+      Bcm2835::GPIO.clear cepin
+    end
+
+    def csn_high
+      Bcm2835::GPIO.set csnpin
+    end
+
+    def csn_low
+      Bcm2835::GPIO.clear csnpin
+    end
+
+  end
+end

data/lib/nrf24/constants.rb

@@ -0,0 +1,99 @@
+class NRF24
+
+  COMMANDS = {
+      :r_register => 0x00,
+      :w_register => 0x20,
+      :activate => 0x50, # non-plus register only
+      :r_rx_pl_wid => 0x60,
+      :r_rx_payload => 0x61,
+      :w_tx_payload => 0xa0,
+      :w_ack_payload => 0xa8,
+      :w_tx_payload_noack => 0xb0,
+      :flush_tx => 0xe1,
+      :flush_rx => 0xe2,
+      :reuse_tx_pl => 0xe3,
+      :nop => 0xff
+  }
+
+  REGS = {
+      :config => 0x00, # Configuration Register
+      :en_aa => 0x01, # Enable ‘Auto Acknowledgment’ Function Disable this functionality to be compatible with nRF2401,
+      :en_rxaddr => 0x02, # Enabled RX Addresses
+      :setup_aw => 0x03, # Setup of Address Widths (common for all data pipes)
+      :setup_retr => 0x04, # Setup of Automatic Retransmission
+      :rf_ch => 0x05, # RF Channel
+      :rf_setup => 0x06, # RF Setup Register (power, rate)
+      :nrf_status => 0x07, # a.k.a. nrf24l01.rbStatus
+      :status => 0x07,
+      :observe_tx => 0x08, # Transmit observe register (packets lost, retransmits)
+      :cd => 0x09, # Legacy (nRF24l01 non+) name
+      :rpd => 0x09, # Received power detection (1 == > -64dBm)
+
+      :rx_addr_p0 => 0x0a, # Receive address data pipe 0. 5 Bytes maximum length. (LSByte is written first. Write the number of bytes defined by SETUP_AW)
+      :rx_addr_p1 => 0x0b, # Receive address data pipe 1. 5 Bytes maximum length. (LSByte is written first. Write the number of bytes defined by SETUP_AW)
+      :rx_addr_p2 => 0x0c, # Receive address data pipe 2. Only LSB. MSBytes are equal to RX_ADDR_P1[39:8]
+      :rx_addr_p3 => 0x0d, # Receive address data pipe 3. Only LSB. MSBytes are equal to RX_ADDR_P1[39:8]
+      :rx_addr_p4 => 0x0e, # Receive address data pipe 4. Only LSB. MSBytes are equal to RX_ADDR_P1[39:8]
+      :rx_addr_p5 => 0x0f, # Receive address data pipe 5. Only LSB. MSBytes are equal to RX_ADDR_P1[39:8]
+
+      :tx_addr => 0x10, # Transmit address. Used for a PTX device only. (LSByte is written first) Set RX_ADDR_P0 equal to this address to handle automatic acknowledge if this is a PTX device with Enhanced ShockBurst™ enabled.
+
+      :rx_pw_p0 => 0x11, # Number of bytes in RX payload in data pipe 0-5 (1 to 32 bytes).
+      :rx_pw_p1 => 0x12, #
+      :rx_pw_p2 => 0x13, # 0 Pipe not used
+      :rx_pw_p3 => 0x14, # 1 = 1 byte
+      :rx_pw_p4 => 0x15, # …
+      :rx_pw_p5 => 0x16, # 32 = 32 bytes
+
+      :fifo_status => 0x17, # FIFO Status Register
+      :dynpd => 0x1c,
+      :feature => 0x1d
+  }
+
+  # CONFIG
+  MASK_RX_DR = 6
+  MASK_TX_DS = 5
+  MASK_MAX_RT = 4
+  EN_CRC = 3
+  CRCO = 2
+  PWR_UP = 1
+  PRIM_RX = 0
+
+  # SETUP_RETR
+  ARD = 4
+  ARC = 0
+
+  # STATUS
+  RX_DR = 6 # Data Ready RX FIFO interrupt
+  TX_DS = 5 # Data Sent TX FIFO interrupt
+  MAX_RT = 4 # Maximum number of TX retransmits interrupt Write 1 to clear bit. If MAX_RT is asserted it must be cleared to enable further communication.
+  RX_P_NO = 1 # bit 3:1 Data pipe number for the payload available for reading from RX_FIFO 000-101: Data Pipe Number 110: Not Used 111: RX FIFO Empty
+  TX_FULL = 0 # TX FIFO full flag. 1: TX FIFO full. 0: Available locations in TX FIFO.
+
+  # observe_tx
+  PLOS_CNT = 4 # 7:4 Count lost packets. The counter is overflow protected to 15, and discontinues at max until reset. The counter is reset by writing to RF_CH.
+  ARC_CNT = 0 # 3:0 Count retransmitted packets.
+
+  # FIFO_STATUS
+  TX_REUSE = 6
+  FIFO_TX_FULL = 5
+  FIFO_TX_EMPTY = 4
+  FIFO_RX_FULL = 1
+  FIFO_RX_EMPTY = 0
+
+  # FEATURE
+  EN_DPL = 2
+  EN_ACK_PAY = 1
+  EN_DYN_ACK = 0
+
+  # RF_SETUP
+  RF_DR_LOW = 5
+  PLL_LOCK = 4
+  RF_DR_HIGH = 3
+  RF_PWR_LOW = 1
+  RF_PWR_HIGH = 2
+  LNA_HCURR = 0
+
+   REGISTER_MASK = 0x1F
+
+end

data/lib/nrf24/nrf24-ruby.rb

@@ -0,0 +1,446 @@
+require_relative 'constants'
+class NRF24
+
+  class OverSizedPayload < RuntimeError
+  end
+
+  class TX_Timeout < RuntimeError
+  end
+
+  attr_reader :static_payload_size
+
+  def self.begin *opts, &block
+    nrf = NRF24.new *opts
+    nrf.instance_eval &block if block_given?
+  ensure
+    nrf.send :radio_deinit
+  end
+
+  def start_listening
+    set_register :config, get_register(:config) | bv(PRIM_RX)
+    clear_interrupt_flags
+    ce_high
+
+    set_register :rx_addr_p0, @pipe0_reading_address if @pipe0_reading_address # Restore address, as this could be overwritten during a PTX cycle (Pipe 0 is used for receiving auto-acks)
+
+    flush_tx if get_register(:feature)[EN_ACK_PAY] > 0
+  end
+
+  def stop_listening
+    ce_low
+    flush_tx if get_register(:feature)[EN_ACK_PAY] > 0
+    set_register :config, get_register(:config) & inv_bv(PRIM_RX)
+    set_register :en_rxaddr, get_register(:en_rxaddr) | 1
+  end
+
+  def write_no_ack payload, *args
+    write(payload, :no_ack, *args)
+  end
+
+  def write payload, type = :ack, timeout = 2
+    start = Time.now
+
+    while fifo_tx_full?
+      if status[MAX_RT] > 0
+        set_register :nrf_status, bv(MAX_RT)
+        return :max_rt
+      end
+      raise TX_Timeout, "TX FIFO full" if Time.now - start > timeout
+    end
+
+    write_payload payload, type
+
+    pulse_ce
+  end
+
+  def write_payload payload, type = :ack
+    if dynamic_payload_enabled?
+      raise OverSizedPayload if payload.size > 32
+    else
+      raise OverSizedPayload if payload.size > static_payload_size
+      padding = static_payload_size - payload.size
+    end
+
+    with_csn {
+      spi.write COMMANDS[type == :no_ack ? :w_tx_payload_noack : :w_tx_payload]
+      spi.write payload
+      spi.write ([0] * padding)
+    }
+  end
+
+  def open_writing_pipe address
+    set_register :rx_addr_p0, address
+    set_register :tx_addr, address
+    set_register :rx_pw_p0, static_payload_size
+  end
+
+  def set_ack_payload pipe, payload
+    raise OverSizedPayload, "ack payload can be 32 bytes max!" if payload.size > 32
+    with_csn {
+      spi.write COMMANDS[:w_ack_payload] | (pipe & 7)
+      spi.write payload
+    }
+  end
+
+  def enable_auto_ack pipes = :all
+    if pipes == :all
+      set_register :en_aa, 0b111111
+    elsif pipes.is_a? Enumerable
+      pipes.map { |p| enable_auto_ack p }
+    else
+      return if pipes > 5
+      set_register :en_aa, get_register(:en_aa) | bv(pipes)
+    end
+  end
+
+  def disable_auto_ack pipes = :all
+    if pipes == :all
+      set_register :en_aa, 0
+    elsif pipes.is_a? Enumerable
+      pipes.map { |p| disable_auto_ack p }
+    else
+      return if pipes > 5
+      set_register :en_aa, get_register(:en_aa) & inv_bv(pipes)
+    end
+  end
+
+  def read
+    payload = read_payload
+    clear_interrupt_flags
+    payload
+  end
+
+  def read_payload
+    send_command :r_rx_payload, payload_size
+  end
+
+  def open_reading_pipe pipe, address
+    @pipe0_reading_address = address if pipe == 0
+
+    if pipe <= 5
+      if pipe < 2
+        set_register REGS[:rx_addr_p0] + pipe, address
+      else
+        set_register REGS[:rx_addr_p0] + pipe, address.first # Only LSB TODO Handle Numeric (byte) address
+      end
+      set_register REGS[:rx_pw_p0] + pipe, static_payload_size
+
+      set_register :en_rxaddr, get_register(:en_rxaddr) | bv(pipe)
+    end
+  end
+
+  def close_reading_pipe pipe
+    set_register :en_rxaddr, get_register(:en_rxaddr) & inv_bv(pipe)
+  end
+
+  def payload_size
+    if dynamic_payload_enabled?
+      get_dynamic_payload_size
+    else
+      static_payload_size
+    end
+  end
+
+  def set_payload_size pipe, size
+    if pipe.is_a? Enumerable
+      pipe.map { |p| set_payload_size p, size }
+    else
+      return if pipe > 5 # Lets make sure not to screw up other regs
+      set_register(REGS[:rx_pw_p0] + pipe, size)
+    end
+  end
+
+  def get_dynamic_payload_size
+    send_command :r_rx_pl_wid, 1
+  end
+
+  def enable_dynamic_payloads
+    set_register :feature, get_register(:feature) | bv(EN_DPL)
+    set_register :dynpd, 63 # Enable for all pipes
+  end
+
+  def disable_dynamic_payloads
+    set_register :feature, get_register(:feature) & inv_bv(EN_DPL)
+    set_register :dynpd, 0
+  end
+
+  def dynamic_payload_enabled?
+    get_register(:feature)[EN_DPL] > 0
+  end
+
+  def power_up
+    config = get_register(:config)
+    if config[PWR_UP] == 0
+      set_register :config, config | bv(PWR_UP)
+      sleep 0.01
+    end
+  end
+
+  def power_down
+    ce_low
+    config = get_register(:config) & inv_bv(PWR_UP)
+    set_register :config, config
+  end
+
+  def channel
+    get_register :rf_ch
+  end
+
+  def set_channel ch
+    set_register :rf_ch, ch
+  end
+
+  def rf_setup datarate = :rate_1mbps, power = :max_power
+    available_rates = {
+        :rate_250kbps => 32, 250 => 32,
+        :rate_1mbps => 0, 1 => 0, 1000 => 0,
+        :rate_2mbps => 8, 2 => 8, 2000 => 8
+    }
+
+    pa_settings = {
+        :min_power => 0, -18 => 0, 18 => 0,
+        :low_power => 2, -12 => 2, 12 => 2,
+        :high_power => 4, -6 => 4, 6 => 4,
+        :max_power => 6, 0 => 6
+    }
+
+    rate = available_rates[datarate]
+    power = pa_settings[power]
+
+    return nil unless rate && power
+
+    set_register :rf_setup, (rate | power)
+    get_register :rf_setup
+  end
+
+  def datarate
+    rf_setup = get_register :rf_setup
+
+    if rf_setup[RF_DR_LOW] == 1
+      :rate_250kbps
+    elsif rf_setup[RF_DR_HIGH] == 1
+      :rate_2mbps
+    else
+      :rate_1mbps
+    end
+  end
+
+  def crc_length
+    config = get_register(:config)
+
+    if config[EN_CRC] > 0 or get_register(:en_aa) > 0
+      config[CRCO] == 1 ? :crc_16 : :crc_8
+    else
+      :crc_none
+    end
+  end
+
+  def set_crc_length length
+    config = get_register(:config) & (~(bv(CRCO) | bv(EN_CRC)) & 0xff)
+
+    if [:crc_16, 16, 2].include? length
+      config |= (bv(EN_CRC) | bv(CRCO))
+    elsif [:crc_8, 8, 1].include? length
+      config |= bv(EN_CRC)
+    end
+    set_register :config, config
+  end
+
+  def disable_crc
+    set_register :config, get_register(:config) & inv_bv(EN_CRC)
+  end
+
+  def set_retries delay, count
+    set_register :setup_retr, ((delay & 0xf) << ARD) | ((count & 0xf) << ARC)
+  end
+
+  def set_tx_address addr
+    set_register :tx_addr, addr
+  end
+
+  def address_width
+    @address_width || (get_register(:setup_aw) + 2)
+  end
+
+  def set_address_width aw = 5
+    aw = (aw - 2) % 4;
+    set_register :setup_aw, aw
+    @address_width = aw + 2
+  end
+
+  def flush_tx
+    send_command :flush_tx
+  end
+
+  def flush_rx
+    send_command :flush_rx
+  end
+
+  def reuse_tx_payload
+    set_register :nrf_status, bv(MAX_RT)
+    send_commnad :reuse_tx_pl
+    pulse_ce
+  end
+
+  def data_available?
+    (status >> RX_P_NO) & 0b111 if not fifo_rx_empty?
+  end
+
+  def fifo_tx_full?
+    get_register(:fifo_status)[FIFO_TX_FULL] > 0
+  end
+
+  def fifo_tx_empty?
+    get_register(:fifo_status)[FIFO_TX_EMPTY] > 0
+  end
+
+  def fifo_rx_full?
+    get_register(:fifo_status)[FIFO_RX_FULL] > 0
+  end
+
+  def fifo_rx_empty?
+    get_register(:fifo_status)[FIFO_RX_EMPTY] > 0
+  end
+
+  def fifo_flags
+    flags = []
+    fifo_status = get_register(:fifo_status)
+
+    flags << :tx_full if fifo_tx_full?
+    flags << :tx_empty if fifo_tx_empty?
+    flags << :rx_full if fifo_rx_full?
+    flags << :rx_empty if fifo_rx_empty?
+
+    flags
+  end
+
+  def received_power
+    get_register(:rpd)
+  end
+
+  def clear_interrupt_flags
+    set_register :nrf_status, (1 << RX_DR) | (1 << TX_DS) | (1 << MAX_RT)
+  end
+
+  def activate
+    send_command :activate, 0x73
+  end
+
+  def status
+    with_csn {
+      spi.read
+    }
+  end
+
+  def set_register reg, value
+    reg = REGS[reg] unless reg.is_a? Numeric
+    with_csn {
+      spi.write(COMMANDS[:w_register] | (REGISTER_MASK & reg))
+      spi.write value
+    }
+  end
+
+  def get_register reg, len = 1
+    reg = REGS[reg] unless reg.is_a? Numeric
+    with_csn {
+      spi.write(COMMANDS[:r_register] | (REGISTER_MASK & reg))
+      len == 1 ? spi.read : spi.read(len) # do not return an array when len == 1
+    } if reg
+  end
+
+  def send_command command, data_len = 0
+    command = COMMANDS[command] unless command.is_a? Numeric
+    with_csn {
+      spi.write command
+      spi.read(data_len) if data_len > 0
+    }
+  end
+
+  def print_regs
+    REGS.each do |i, v|
+      len = [:rx_addr_p0, :rx_addr_p1, :tx_addr].include?(i) ? address_width : 1
+      puts "register #{v.to_s(16).rjust(2, "0")} (#{i}): #{get_register i, len}"
+    end
+  end
+
+  private
+
+  alias_method :channel=, :set_channel
+  alias_method :tx_address=, :set_tx_address
+  alias_method :address_width=, :set_address_width
+  alias_method :crc_length=, :set_crc_length
+
+  attr_reader :spi, :cepin, :csnpin
+
+  def initialize opts = {}
+    opts = {cepin: 22, csnpin: 8, static_payload_size: 32, channel: 76, driver: Bcm2835Driver}.merge opts
+
+    @cepin = opts[:cepin]
+    @csnpin = opts[:csnpin]
+    @static_payload_size = [opts[:static_payload_size], 32].min
+    @channel = opts[:channel]
+
+    extend opts[:driver]
+
+    init_io
+    radio_init
+
+    @pipe0_reading_address = nil
+  end
+
+  def radio_init
+    activate # nrf24l01 (non-plus) compatibility
+
+    set_address_width
+
+    set_channel @channel
+
+    set_payload_size (0..5), static_payload_size
+    disable_dynamic_payloads
+    enable_auto_ack
+
+    set_register :config, ((1 << EN_CRC) | (1 << CRCO) | (1 << PWR_UP) | (1 << PRIM_RX))
+
+    clear_interrupt_flags
+
+    flush_rx
+    flush_tx
+  end
+
+  def radio_deinit
+    ce_low
+    radio_init
+    rf_setup
+    set_channel 0
+  end
+
+  def with_csn
+    csn_low
+    ret = yield
+    csn_high
+    ret
+  end
+
+  def with_ce
+    ce_high
+    ret = yield
+    ce_low
+    ret
+  end
+
+  def pulse_ce us = 10
+    ce_high
+    sleep(0.000001 * us)
+    ce_low
+  end
+
+  # Low level bit vector stuff
+  def bv d
+    1 << d
+  end
+
+  def inv_bv d, mask = 0xff
+    ~(1 << d) & mask
+  end
+
+end

data/lib/nrf24/version.rb

@@ -0,0 +1,3 @@
+class NRF24
+  VERSION = '0.5'
+end

data/nrf24-ruby.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nrf24/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nrf24l01-ruby"
+  spec.version       = NRF24::VERSION
+  spec.authors       = ["Rogier Lodewijks"]
+  spec.email         = ["rogier@lodewijks.org"]
+
+  spec.summary       = %q{nrf24-ruby is a pure Ruby library for controlling the ubiquitous Nordic nRF24l01(+) radio module.}
+  spec.description   = %q{nrf24-ruby is a pure Ruby library for controlling the ubiquitous Nordic nRF24l01(+) radio module. Currently primary target is the Raspberry Pi, but it shouldn't be too hard to port to a different platform (supporting SPI). No webserver, no message bus, no frills, yet a fully functional lib written in clear Ruby.}
+
+  spec.homepage      = "https://github.com/eflukx/nrf24-ruby"
+  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", "lib/nrf24"]
+  
+  spec.add_dependency 'bcm2835', '~> 0.0', '>= 0.0.1'
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: nrf24l01-ruby
+version: !ruby/object:Gem::Version
+  version: '0.5'
+platform: ruby
+authors:
+- Rogier Lodewijks
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bcm2835
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+description: nrf24-ruby is a pure Ruby library for controlling the ubiquitous Nordic
+  nRF24l01(+) radio module. Currently primary target is the Raspberry Pi, but it shouldn't
+  be too hard to port to a different platform (supporting SPI). No webserver, no message
+  bus, no frills, yet a fully functional lib written in clear Ruby.
+email:
+- rogier@lodewijks.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- binlib/libbcm2835.so
+- example/nrf24_listening_example.rb
+- lib/nrf24-ruby.rb
+- lib/nrf24/bcm2835_driver.rb
+- lib/nrf24/constants.rb
+- lib/nrf24/nrf24-ruby.rb
+- lib/nrf24/version.rb
+- nrf24-ruby.gemspec
+homepage: https://github.com/eflukx/nrf24-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib/nrf24
+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.5
+signing_key: 
+specification_version: 4
+summary: nrf24-ruby is a pure Ruby library for controlling the ubiquitous Nordic nRF24l01(+)
+  radio module.
+test_files: []