beaglebone 1.0.4

data/lib/beaglebone/spi.rb

@@ -0,0 +1,322 @@
+module Beaglebone
+
+  module SPI
+    #some ioctl defines
+    IOC_NONE  = 0
+    IOC_WRITE = 1
+    IOC_READ  = 2
+
+    IOC_NRBITS = 8
+    IOC_TYPEBITS =  8
+    IOC_SIZEBITS = 14
+    IOC_DIRBITS = 2
+
+    IOC_NRSHIFT   = 0
+    IOC_TYPESHIFT = IOC_NRSHIFT+IOC_NRBITS
+    IOC_SIZESHIFT = IOC_TYPESHIFT+IOC_TYPEBITS
+    IOC_DIRSHIFT  = IOC_SIZESHIFT+IOC_SIZEBITS
+
+    #spi defines
+    SPI_CPHA = 0x01
+    SPI_CPOL = 0x02
+
+    SPI_MODE_0 = (0|0)
+    SPI_MODE_1 = (0|SPI_CPHA)
+    SPI_MODE_2 = (SPI_CPOL|0)
+    SPI_MODE_3 = (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_IOC_MAGIC = 'k'.ord
+
+    SPI_IOC_RD_MODE = 2147576577 #ior(SPI_IOC_MAGIC, 1, 1)
+    SPI_IOC_WR_MODE = 1073834753 #iow(SPI_IOC_MAGIC, 1, 1)
+
+    SPI_IOC_RD_LSB_FIRST = 2147576578 #ior(SPI_IOC_MAGIC, 2, 1)
+    SPI_IOC_WR_LSB_FIRST = 1073834754 #iow(SPI_IOC_MAGIC, 2, 1)
+
+    SPI_IOC_RD_BITS_PER_WORD = 2147576579 #ior(SPI_IOC_MAGIC, 3, 1)
+    SPI_IOC_WR_BITS_PER_WORD = 1073834755 #iow(SPI_IOC_MAGIC, 3, 1)
+
+    SPI_IOC_RD_MAX_SPEED_HZ = 2147773188 #ior(SPI_IOC_MAGIC, 4, 4)
+    SPI_IOC_WR_MAX_SPEED_HZ = 1074031364 #iow(SPI_IOC_MAGIC, 4, 4)
+
+    SPI_IOC_MESSAGE_1 = 1075866368
+
+    SPI_IOC_TRANSFER_STRUCT_SIZE = 32
+
+    @spistatus = {}
+    @spimutex = Mutex.new
+
+    class << self
+
+      attr_accessor :spistatus, :spimutex
+      def xfer(spi, tx_data, readbytes=0, speed=nil, delay=nil, bpw=nil)
+        check_spi_enabled(spi)
+
+        speed = speed || get_spi_status(spi, :speed)
+        delay = delay || 0
+        bpw   = bpw || get_spi_status(spi, :bpw)
+
+        if tx_data.size > readbytes
+          readbytes = tx_data.size
+        end
+
+        rx_data = ' ' * readbytes
+
+        lock_spi(spi) do
+          spi_fd = get_spi_status(spi, :fd_spi)
+
+          ### SPI IOC transfer structure
+          # __u64       tx_buf;
+          # __u64       rx_buf;
+          #
+          # __u32       len;
+          # __u32       speed_hz;
+          #
+          # __u16       delay_usecs;
+          # __u8        bits_per_word;
+          # __u8        cs_change;
+          # __u32       pad;
+          ###
+
+          msg = [ tx_data, 0,
+                  rx_data, 0,
+                  readbytes,
+                  speed,
+                  delay,
+                  bpw,
+                  0,
+                  0].pack('pLpLLLSCCL')
+
+          #ioctl call to begin data transfer
+          spi_fd.ioctl(SPI_IOC_MESSAGE_1, msg)
+          #speedup with defined int
+          #spi_fd.ioctl(spi_ioc_message(1), msg)
+
+        end
+        rx_data
+      end
+
+      def file(spi)
+        check_spi_enabled(spi)
+        get_spi_status(spi, :fd_spi)
+      end
+
+      def set_speed(spi, speed)
+        speed = speed.to_i
+        raise ArgumentError, "Speed (#{speed.to_s}) must be a positive integer" unless speed > 0
+
+        check_spi_enabled(spi)
+        spi_fd = get_spi_status(spi, :fd_spi)
+
+        spi_fd.ioctl(SPI_IOC_WR_MAX_SPEED_HZ, [speed].pack('L'))
+        spi_fd.ioctl(SPI_IOC_RD_MAX_SPEED_HZ, [speed].pack('L'))
+        set_spi_status(spi, :speed, speed)
+      end
+
+      def set_mode(spi, mode)
+        check_spi_enabled(spi)
+        raise ArgumentError, "Mode (#{mode.to_s}) is unknown" unless [SPI_MODE_0, SPI_MODE_1, SPI_MODE_2, SPI_MODE_3].include?(mode)
+        spi_fd = get_spi_status(spi, :fd_spi)
+
+        spi_fd.ioctl(SPI_IOC_WR_MODE, [mode].pack('C'))
+        spi_fd.ioctl(SPI_IOC_RD_MODE, [mode].pack('C'))
+      end
+
+      def set_bpw(spi, bpw)
+        bpw = bpw.to_i
+        raise ArgumentError, "BPW (#{bpw.to_s}) must be a positive integer" unless bpw > 0
+
+        check_spi_enabled(spi)
+        spi_fd = get_spi_status(spi, :fd_spi)
+
+        spi_fd.ioctl(SPI_IOC_WR_BITS_PER_WORD, [bpw].pack('C'))
+        spi_fd.ioctl(SPI_IOC_RD_BITS_PER_WORD, [bpw].pack('C'))
+        set_spi_status(spi, :bpw, bpw)
+      end
+
+      def setup(spi, mode=nil, speed=1000000, bpw=8)
+        check_spi_valid(spi)
+
+        #make sure spi not already enabled
+        return if get_spi_status(spi)
+
+        mode = mode || SPI_MODE_0
+
+        spiinfo = SPIS[spi]
+
+        #ensure dtb is loaded
+        Beaglebone::device_tree_load("#{spiinfo[:devicetree]}") if spiinfo[:devicetree]
+
+        #open the spi device.
+        spi_fd = File.open("#{spiinfo[:dev]}#{SPIS[:counter]}.0", 'r+')
+
+        set_spi_status(spi, :fd_spi, spi_fd)
+        set_spi_status(spi, :mutex, Mutex.new)
+
+        set_mode(spi, mode)
+        set_bpw(spi, bpw)
+        set_speed(spi, speed)
+
+        SPIS[:counter] += 1
+
+        spiinfo[:pins].each do |pin|
+          Beaglebone::set_pin_status(pin, :spi, spiinfo[:id])
+          Beaglebone::set_pin_status(pin, :type, :spi)
+          Beaglebone::set_pin_status(pin, :fd_spi, spi_fd)
+        end
+
+      end
+
+      def disable(spi)
+        check_spi_valid(spi)
+        check_spi_enabled(spi)
+
+        SPIS[spi][:pins].each do |pin|
+          disable_spi_pin(pin)
+        end
+
+        delete_spi_status(spi)
+
+        #removing spi tree causes a crash... can't really disable.
+        #Beaglebone::device_tree_unload("#{SPIS[spi][:devicetree]}") if SPIS[spi][:devicetree]
+
+      end
+
+      def cleanup
+        #reset all spis we've used and unload the device tree
+        spistatus.clone.keys.each { |spi| disable(spi)}
+      end
+
+      private
+
+      def check_spi_valid(spi)
+        raise ArgumentError, "Invalid spi Specified #{spi.to_s}" unless SPIS[spi] && SPIS[spi][:sclk]
+        spiinfo = SPIS[spi.to_sym.upcase]
+
+        unless spiinfo[:sclk] && [nil,:spi].include?(Beaglebone::get_pin_status(spiinfo[:sclk], :type))
+          raise StandardError, "SCLK Pin for #{spi.to_s} in use"
+        end
+
+        unless spiinfo[:d0] && [nil,:spi].include?(Beaglebone::get_pin_status(spiinfo[:d0], :type))
+          raise StandardError, "D0 Pin for #{spi.to_s} in use"
+        end
+
+        unless spiinfo[:d1] && [nil,:spi].include?(Beaglebone::get_pin_status(spiinfo[:d1], :type))
+          raise StandardError, "D1 Pin for #{spi.to_s} in use"
+        end
+
+        unless spiinfo[:cs0] && [nil,:spi].include?(Beaglebone::get_pin_status(spiinfo[:cs0], :type))
+          raise StandardError, "CS0 Pin for #{spi.to_s} in use"
+        end
+      end
+
+      def lock_spi(spi)
+        check_spi_enabled(spi)
+        mutex = get_spi_status(spi, :mutex)
+
+        mutex.synchronize do
+          yield
+        end
+      end
+
+      def check_spi_enabled(spi)
+        raise ArgumentError, "spi not enabled #{spi.to_s}" unless get_spi_status(spi)
+      end
+
+      def disable_spi_pin(pin)
+        Beaglebone::check_valid_pin(pin, :spi)
+
+        Beaglebone::delete_pin_status(pin)
+      end
+
+      #ports of ioctl definitions
+      def ioc(dir,type,nr,size)
+        (((dir) << IOC_DIRSHIFT) |
+            ((type) << IOC_TYPESHIFT) |
+            ((nr) << IOC_NRSHIFT) |
+            ((size) << IOC_SIZESHIFT))
+      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 spi_msgsize(n)
+        n*SPI_IOC_TRANSFER_STRUCT_SIZE < 1<<IOC_SIZEBITS ? n*SPI_IOC_TRANSFER_STRUCT_SIZE : 0
+      end
+
+      def spi_ioc_message(n)
+        iow(SPI_IOC_MAGIC, 0, spi_msgsize(n))
+      end
+
+      def get_spi_status(spi, key = nil)
+        spimutex.synchronize do
+          if key
+            spistatus[spi] ? spistatus[spi][key] : nil
+          else
+            spistatus[spi]
+          end
+        end
+      end
+
+      def set_spi_status(spi, key, value)
+        spimutex.synchronize do
+          spistatus[spi]    ||= {}
+          spistatus[spi][key] = value
+        end
+      end
+
+      def delete_spi_status(spi, key = nil)
+        spimutex.synchronize do
+          if key.nil?
+            spistatus.delete(spi)
+          else
+            spistatus[spi].delete(key) if spistatus[spi]
+          end
+        end
+      end
+
+    end
+  end
+
+  #oo interface
+  class SPIDevice
+    def initialize(spi,  mode=nil, speed=1000000, bpw=8)
+      @spi = spi
+      SPI::setup(@spi, mode, speed, bpw)
+    end
+
+    def xfer(tx_data, readbytes=0, speed=nil, delay=nil, bpw=nil)
+      SPI::xfer(@spi, tx_data, readbytes, speed, delay, bpw)
+    end
+
+    def disable
+      SPI::disable(@spi)
+    end
+
+    def set_speed(speed)
+      SPI::set_speed(@spi, speed)
+    end
+
+    def set_mode(mode)
+      SPI::set_mode(@spi, mode)
+    end
+
+    def set_bpw(bpw)
+      SPI::set_bpw(@spi, bpw)
+    end
+
+  end
+
+end

data/lib/beaglebone/uart.rb

@@ -0,0 +1,388 @@
+module Beaglebone
+  module UART
+    SPEEDS = [ 110, 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 56000, 57600, 115200 ]
+    @uartstatus = {}
+    @uartmutex = Mutex.new
+
+    class << self
+      attr_accessor :uartstatus, :uartmutex
+
+      def readchar(uart)
+        readchars(uart, 1)
+      end
+
+      def readchars(uart, bytes)
+        check_uart_enabled(uart)
+        ensure_read_lock(uart)
+
+        buffer = ''
+
+        pin_rx = UARTS[uart][:rx]
+
+        Beaglebone::check_valid_pin(pin_rx, :uart)
+
+        fd = Beaglebone::get_pin_status(pin_rx, :fd_uart)
+
+        set_uart_status(uart, :waiting, true)
+
+        while bytes > 0 do
+          buffer << fd.readchar
+          bytes -= 1
+        end
+        set_uart_status(uart, :waiting, false)
+
+        buffer
+      end
+
+      def readline(uart)
+        check_uart_enabled(uart)
+        ensure_read_lock(uart)
+
+        pin_rx = UARTS[uart][:rx]
+
+        Beaglebone::check_valid_pin(pin_rx, :uart)
+
+        fd = Beaglebone::get_pin_status(pin_rx, :fd_uart)
+
+        set_uart_status(uart, :waiting, true)
+
+        data = fd.readline.strip
+
+        set_uart_status(uart, :waiting, false)
+
+        data
+      end
+
+      def each_char(uart)
+        loop do
+          data = readchars(uart, 1)
+          yield data
+        end
+
+      end
+
+      def each_chars(uart, chars)
+        loop do
+          data = readchars(uart, chars)
+          yield data
+        end
+      end
+
+      def each_line(uart)
+        loop do
+          data = readline(uart)
+          yield data
+        end
+      end
+
+      def writeln(uart, data)
+        write(uart, data + "\n")
+      end
+
+      def write(uart, data)
+        check_uart_enabled(uart)
+
+        pin_tx = UARTS[uart][:tx]
+
+        Beaglebone::check_valid_pin(pin_tx, :uart)
+
+        fd = Beaglebone::get_pin_status(pin_tx, :fd_uart)
+
+        ret = fd.write(data)
+        fd.flush
+
+        ret
+      end
+
+      def run_once_on_each_line(callback, uart)
+        run_on_each_line(callback, uart, 1)
+      end
+
+      def run_on_each_line(callback, uart, repeats=nil)
+        check_uart_enabled(uart)
+
+        raise StandardError, "Already waiting for data on uart: #{uart}" if get_uart_status(uart, :waiting)
+        raise StandardError, "Already waiting for data on uart: #{uart}" if get_uart_status(uart, :thread)
+
+        thread = Thread.new(callback, uart, repeats) do |c, u, r|
+          begin
+            count = 0
+            each_line(u) do |line|
+
+              c.call(u, line, count) if c
+
+              count += 1
+              break if r && count >= r
+            end
+          rescue => ex
+            puts ex
+            puts ex.backtrace
+          ensure
+            delete_uart_status(u, :thread)
+            set_uart_status(uart, :waiting, false)
+          end
+        end
+        set_uart_status(uart, :thread, thread)
+      end
+
+      def run_once_on_each_char(callback, uart)
+        run_once_on_each_chars(callback, uart, 1)
+      end
+
+      def run_once_on_each_chars(callback, uart, chars=1)
+        run_on_each_chars(callback, uart, chars, 1)
+      end
+
+      def run_on_each_char(callback, uart, repeats=nil)
+        run_on_each_chars(callback, uart, 1, repeats)
+      end
+
+      def run_on_each_chars(callback, uart, chars=1, repeats=nil)
+        check_uart_enabled(uart)
+
+        raise StandardError, "Already waiting for data on uart: #{uart}" if get_uart_status(uart, :waiting)
+        raise StandardError, "Already waiting for data on uart: #{uart}" if get_uart_status(uart, :thread)
+
+        thread = Thread.new(callback, uart, chars, repeats) do |c, u, ch, r|
+          begin
+            count = 0
+            each_chars(u, ch) do |line|
+
+              c.call(u, line, count) if c
+
+              count += 1
+              break if r && count >= r
+            end
+          rescue => ex
+            puts ex
+            puts ex.backtrace
+          ensure
+            delete_uart_status(u, :thread)
+            set_uart_status(uart, :waiting, false)
+          end
+        end
+        set_uart_status(uart, :thread, thread)
+      end
+
+      def set_speed(uart, speed)
+        check_uart_valid(uart)
+        check_speed_valid(speed)
+
+        uartinfo = UARTS[uart]
+        system("stty -F #{uartinfo[:dev]} #{speed}")
+      end
+
+      def setup(uart, speed=9600)
+        check_uart_valid(uart)
+        check_speed_valid(speed)
+
+        #make sure uart not already enabled
+        return if get_uart_status(uart)
+
+        uartinfo = UARTS[uart]
+
+        #ensure dtb is loaded
+        Beaglebone::device_tree_load("#{TREES[:UART][:pin]}#{uartinfo[:id]}")
+
+        #open the uart device
+        uart_fd = File.open(uartinfo[:dev], 'r+')
+
+        if uartinfo[:tx]
+          Beaglebone::set_pin_status(uartinfo[:tx], :uart, uartinfo[:id])
+          Beaglebone::set_pin_status(uartinfo[:tx], :type, :uart)
+          Beaglebone::set_pin_status(uartinfo[:tx], :fd_uart, uart_fd)
+        end
+
+        if uartinfo[:rx]
+          Beaglebone::set_pin_status(uartinfo[:rx], :uart, uartinfo[:id])
+          Beaglebone::set_pin_status(uartinfo[:tx], :type, :uart)
+          Beaglebone::set_pin_status(uartinfo[:rx], :fd_uart, uart_fd)
+        end
+
+        system("stty -F #{uartinfo[:dev]} raw")
+        system("stty -F #{uartinfo[:dev]} #{speed}")
+
+        set_uart_status(uart, :fd_uart, uart_fd)
+      end
+
+      def disable(uart)
+        check_uart_valid(uart)
+        check_uart_enabled(uart)
+
+        stop_read_wait(uart)
+
+        disable_uart_pin(UARTS[uart][:rx]) if UARTS[uart][:rx]
+        disable_uart_pin(UARTS[uart][:tx]) if UARTS[uart][:tx]
+
+        delete_uart_status(uart)
+      end
+
+      #stop background read
+      def stop_read_wait(uart)
+        thread = get_uart_status(uart, :thread)
+
+        thread.exit if thread
+        thread.join if thread
+      end
+
+      def cleanup
+        #reset all UARTs we've used and unload the device tree
+        uartstatus.clone.keys.each { |uart| disable(uart)}
+      end
+
+      private
+
+      def get_uart_status(uart, key = nil)
+        uartmutex.synchronize do
+          if key
+            uartstatus[uart] ? uartstatus[uart][key] : nil
+          else
+            uartstatus[uart]
+          end
+        end
+      end
+
+      def set_uart_status(uart, key, value)
+        uartmutex.synchronize do
+          uartstatus[uart]    ||= {}
+          uartstatus[uart][key] = value
+        end
+      end
+
+      def delete_uart_status(uart, key = nil)
+        uartmutex.synchronize do
+          if key.nil?
+            uartstatus.delete(uart)
+          else
+            uartstatus[uart].delete(key) if uartstatus[uart]
+          end
+        end
+      end
+
+      def check_uart_valid(uart)
+        raise ArgumentError, "Invalid UART Specified #{uart.to_s}" unless UARTS[uart]
+        uartinfo = UARTS[uart.to_sym.upcase]
+
+        unless uartinfo[:tx] && [nil,:uart].include?(Beaglebone::get_pin_status(uartinfo[:tx], :type))
+          raise StandardError, "TX Pin for #{uart.to_s} in use"
+        end
+
+        unless uartinfo[:rx] && [nil,:uart].include?(Beaglebone::get_pin_status(uartinfo[:rx], :type))
+          raise StandardError, "RX Pin for #{uart.to_s} in use"
+        end
+
+      end
+
+      def check_uart_enabled(uart)
+        raise ArgumentError, "UART not enabled #{uart.to_s}" unless get_uart_status(uart)
+      end
+
+      def ensure_read_lock(uart)
+        #ensure we're the only ones reading
+        if get_uart_status(uart, :thread) && get_uart_status(uart, :thread) != Thread.current
+          raise StandardError, "Already waiting for data on uart: #{uart}"
+        end
+
+        if get_uart_status(uart, :waiting) && get_uart_status(uart, :thread) != Thread.current
+          raise StandardError, "Already waiting for data on uart: #{uart}"
+        end
+      end
+
+      def check_speed_valid(speed)
+        raise ArgumentError, "Invalid speed specified: #{speed}" unless SPEEDS.include?(speed)
+      end
+
+      def disable_uart_pin(pin)
+        Beaglebone::check_valid_pin(pin, :uart)
+
+        id = Beaglebone::get_pin_status(pin, :uart)
+
+        Beaglebone::delete_pin_status(pin)
+
+        #removing uart tree causes a crash... can't really disable.
+        return if true
+
+        Beaglebone::device_tree_unload("#{TREES[:UART][:pin]}#{id}")
+
+      end
+
+    end
+  end
+
+  #oo interface
+  class UARTDevice
+    def initialize(uart, speed=9600)
+      @uart = uart
+      UART::setup(@uart, speed)
+    end
+
+    def set_speed(speed)
+      UART::set_speed(@uart, speed)
+    end
+
+    def write(data)
+      UART::write(@uart, data)
+    end
+
+    def writeln(data)
+      UART::writeln(@uart, data)
+    end
+
+    def readchar
+      UART::readchar(@uart)
+    end
+
+    def readchars(bytes)
+      UART::readchars(@uart, bytes)
+    end
+
+    def readline
+      UART::readline(@uart)
+    end
+
+    def each_char(&block)
+      UART::each_char(@uart, &block)
+    end
+
+    def each_chars(chars, &block)
+      UART::each_chars(@uart, chars, &block)
+    end
+
+    def each_line(&block)
+      UART::each_line(@uart, &block)
+    end
+
+    def run_on_each_line(callback, repeats=nil)
+      UART::run_on_each_line(callback, @uart, repeats)
+    end
+
+    def run_once_on_each_line(callback)
+      UART::run_once_on_each_line(callback, @uart)
+    end
+
+    def run_on_each_char(callback, repeats=nil)
+      UART::run_on_each_char(callback, @uart, repeats)
+    end
+
+    def run_once_on_each_char(callback)
+      UART::run_once_on_each_char(callback, @uart)
+    end
+
+    def run_on_each_chars(callback, chars=1, repeats=nil)
+      UART::run_on_each_chars(callback, @uart, chars, repeats)
+    end
+
+    def run_once_on_each_chars(callback, chars=1)
+      UART::run_once_on_each_chars(callback, @uart, chars)
+    end
+
+    def stop_read_wait
+      UART::stop_read_wait(@uart)
+    end
+
+    def disable
+      UART::disable(@uart)
+    end
+
+  end
+end

data/lib/beaglebone.rb

@@ -0,0 +1,8 @@
+require 'beaglebone/beaglebone'
+require 'beaglebone/spi'
+require 'beaglebone/i2c'
+require 'beaglebone/uart'
+require 'beaglebone/pwm'
+require 'beaglebone/ain'
+require 'beaglebone/gpio'
+require 'beaglebone/shiftregister'