beaglebone 1.0.4

data/README.md

@@ -0,0 +1,6 @@
+beaglebone
+==========
+
+Beaglebone Ruby Library
+
+Documentation coming shortly

data/beaglebone.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = 'beaglebone'
+  s.version     = '1.0.4'
+  s.date        = '2014-04-13'
+  s.summary     = 'Beaglebone IO Gem'
+  s.description = 'A Full Featured Beaglebone IO Gem'
+  s.author      = 'Rob Mosher'
+  s.email       = 'nyt-rubygems@countercultured.net'
+  s.files       = `git ls-files`.split("\n")
+  s.homepage    = 'https://github.com/notnyt/beaglebone'
+  s.license     = 'GPL-3.0'
+end

data/examples/ain.rb

@@ -0,0 +1,92 @@
+#!/usr/bin/env ruby
+require 'beaglebone'
+require 'pp'
+
+include  Beaglebone
+
+#analog testing
+#oo methods
+
+#analog read
+p9_33 = AINPin.new(:P9_33)
+loop do
+  puts p9_33.read
+  sleep 0.01
+end
+
+exit
+
+#waiting for analog input change
+p9_33 = AINPin.new(:P9_33)
+pp p9_33.wait_for_change(10, 0.01)
+pp p9_33.wait_for_change(10, 0.01)
+pp p9_33.wait_for_change(10, 0.01)
+
+
+#background analog input with callback
+
+#wait for threshold
+callback = lambda { |pin, mv_last, mv, state_last, state, count|
+  puts "[#{count}] #{pin} #{state_last} -> #{state}     #{mv_last} -> #{mv}"
+}
+p9_33 = AINPin.new(:P9_33)
+p9_33.run_on_threshold(callback, 400, 1200, 5, 0.001)
+
+sleep 5
+p9_33.stop_wait
+
+pp p9_33.wait_for_threshold(200, 1600, 100, 0.01)
+pp p9_33.wait_for_threshold(200, 1600, 100, 0.01)
+pp p9_33.wait_for_threshold(200, 1600, 100, 0.01)
+
+#wait for change
+callback = lambda { |pin, mv_last, mv, count| puts "[#{count}] #{pin} #{mv_last} -> #{mv}" }
+
+p9_33 = AINPin.new(:P9_33)
+
+p9_33.run_on_change(callback, 10, 0.1)
+sleep 5
+p9_33.stop_wait
+
+exit
+
+
+
+#procedural methods
+
+#analog read
+loop do
+  puts AIN.read(:P9_33)
+  sleep 0.01
+end
+exit
+
+#wait for analog input to hit a certrain threshold limit
+pp AIN.wait_for_threshold(:P9_33, 200, 1600, 100, 0.01)
+pp AIN.wait_for_threshold(:P9_33, 200, 1600, 100, 0.01)
+pp AIN.wait_for_threshold(:P9_33, 200, 1600, 100, 0.01)
+pp AIN.wait_for_threshold(:P9_33, 200, 1600, 100, 0.01)
+pp AIN.wait_for_threshold(:P9_33, 200, 1600, 100, 0.01)
+exit
+
+#waiting for analog input change
+pp AIN.wait_for_change(:P9_33, 10, 0.01)
+pp AIN.wait_for_change(:P9_33, 10, 0.01)
+pp AIN.wait_for_change(:P9_33, 10, 0.01)
+
+exit
+
+#background analog input
+callback = lambda { |pin, mv_last, mv, count| puts "[#{count}] #{pin} #{mv_last} -> #{mv}" }
+AIN.run_on_change(callback, :P9_33, 10, 0.1)
+sleep 5
+AIN.stop_wait(:P9_33)
+
+#run when reaching a certain threshold
+callback = lambda { |pin, mv_last, mv, state_last, state, count|
+  puts "[#{count}] #{pin} #{state_last} -> #{state}     #{mv_last} -> #{mv}"
+}
+AIN.run_on_threshold(callback, :P9_33, 400, 1200, 5, 0.001)
+loop do sleep(4000);end
+
+exit

data/examples/gpio.rb

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+require 'beaglebone'
+
+include  Beaglebone
+
+###object oriented methods###
+#flash leds
+led1 = GPIOPin.new(:USR0, :OUT)
+led2 = GPIOPin.new(:USR1, :OUT)
+led3 = GPIOPin.new(:USR2, :OUT)
+led4 = GPIOPin.new(:USR3, :OUT)
+
+5.times do
+  led1.digital_write(:HIGH)
+  sleep 0.25
+  led1.digital_write(:LOW)
+
+  led2.digital_write(:HIGH)
+  sleep 0.25
+  led2.digital_write(:LOW)
+
+  led3.digital_write(:HIGH)
+  sleep 0.25
+  led3.digital_write(:LOW)
+
+  led4.digital_write(:HIGH)
+  sleep 0.25
+  led4.digital_write(:LOW)
+end
+
+exit
+
+#basic GPIO reads and writes
+p9_11 = GPIOPin.new(:P9_11, :IN)
+p9_12 = GPIOPin.new(:P9_12, :OUT)
+
+puts p9_11.digital_read
+p9_12.digital_write(:HIGH)
+puts p9_11.digital_read
+p9_12.digital_write(:LOW)
+puts p9_11.digital_read
+
+
+exit
+
+##gpio edge trigger with callback
+p9_11 = GPIOPin.new(:P9_11, :IN)
+p9_12 = GPIOPin.new(:P9_12, :OUT)
+
+#toggle output pin randomly in a separate there
+Thread.new do
+  loop do
+    sleep rand(100) / 100.0
+    p9_12.digital_write(:LOW)
+    sleep rand(100) / 100.0
+    p9_12.digital_write(:HIGH)
+  end
+end
+
+#run on edge trigger with callback
+callback = lambda { |pin,edge,count| p9_11.stop_edge_wait if count == 10;puts "[#{count}] #{pin} #{edge}"}
+p9_11.run_on_edge(callback, :BOTH)
+
+
+sleep 10000
+exit
+
+#or without callback
+loop do
+  edge = p9_11.wait_for_edge(:RISING)
+  puts "!! TRIGGERED ON #{edge}"
+
+  edge = p9_11.wait_for_edge(:RISING)
+  puts "!! TRIGGERED ON #{edge}"
+
+  edge = p9_11.wait_for_edge(:BOTH)
+  puts "!! TRIGGERED ON #{edge}"
+end
+
+#gpio edge trigger
+p9_11 = GPIOPin.new(:P9_11, :IN)
+p9_12 = GPIOPin.new(:P9_12, :OUT)
+
+Thread.new do
+  loop do
+    sleep rand(100) / 100.0
+    p9_12.digital_write(:LOW)
+    sleep rand(100) / 100.0
+    p9_12.digital_write(:HIGH)
+  end
+end
+
+
+loop do
+  edge = p9_11.wait_for_edge(:RISING)
+  puts "!! TRIGGERED ON #{edge}"
+
+  edge = p9_11.wait_for_edge(:RISING)
+  puts "!! TRIGGERED ON #{edge}"
+
+  edge = p9_11.wait_for_edge(:BOTH)
+  puts "!! TRIGGERED ON #{edge}"
+end
+
+
+
+#shift register via gpio, specified latch, clock, and data pins
+shiftreg = ShiftRegister.new(:P9_11, :P9_12, :P9_13)
+data = 255
+shiftreg.shiftout(data)
+
+exit
+
+
+
+###procedural methods###
+
+#gpio edge trigger callback
+GPIO.pin_mode(:P9_12, :OUT)
+GPIO.pin_mode(:P9_11, :IN)
+GPIO.run_on_edge(lambda { |pin,edge,count| puts "[#{count}] #{pin} -- #{edge}" }, :P9_11, :BOTH)
+
+leds = [ :USR0, :USR1, :USR2, :USR3 ]
+leds.each do |ledpin|
+  GPIO.pin_mode(ledpin, :OUT)
+end
+
+x = 0
+loop do
+#gpio write to led pins
+  leds.each do |ledpin|
+    GPIO.digital_write(ledpin, :LOW)
+  	sleep 0.25
+    GPIO.digital_write(ledpin, :HIGH)
+  end
+	x += 1
+
+	if x == 10
+		GPIO.stop_edge_wait(:P9_11)
+		puts 'STOP'
+	end
+  if x == 15
+    GPIO.run_on_edge(lambda { |pin,edge,count| puts "[#{count}] #{pin} -- #{edge}" }, :P9_11, :BOTH)
+		puts 'OK GO AGAIN'
+		x = 0
+	end
+
+end
+
+
+exit
+
+#gpio edge trigger
+GPIO.pin_mode(:P9_12, :OUT)
+GPIO.pin_mode(:P9_11, :IN)
+
+loop do
+	edge = GPIO.wait_for_edge(:P9_11, :RISING)
+	puts "!! TRIGGERED ON #{edge}"
+end
+
+
+#standard gpio setup and testing
+GPIO.pin_mode(:P9_12, :OUT)
+puts GPIO.enabled?(:P9_12)
+puts GPIO.get_gpio_mode(:P9_12)
+
+#gpio setup for led pins
+leds = [ :USR0, :USR1, :USR2, :USR3 ]
+leds.each do |ledpin|
+	GPIO.pin_mode(ledpin, :OUT)
+end
+
+#gpio write to led pins
+leds.each do |ledpin|
+	GPIO.digital_write(ledpin, :LOW)
+end
+
+
+#gpio write
+loop do
+	GPIO.digital_write(:P9_12, :HIGH)
+	sleep 0.25
+	GPIO.digital_write(:P9_12, :LOW)
+	sleep 0.25
+end
+
+
+GPIO.cleanup
+exit
+
+# gpio read
+GPIO.pin_mode(:P9_12, :IN)
+loop do
+	puts GPIO.digital_read(:P9_12)
+end

data/examples/i2c.rb

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+require 'beaglebone'
+
+
+
+#i2c testing hooked up to LSM303DLHC
+
+#oo method
+i2c = I2CDevice.new(:I2C2)
+
+#put mag into continuous conversation mode
+i2c.write(0x1e, [0x02, 0x00].pack("C*"))
+
+#enable temperatuer sensor, 15hz register update
+i2c.write(0x1e, [0x00, "10010000".to_i(2)].pack("C*") )
+
+#delay for the settings to take effect
+sleep(0.1)
+
+loop do
+
+  #read axis data
+  raw = i2c.read(0x1e, 6, [0x03].pack("C*"))
+
+  #coordinates are signed shorts in x,z,y order
+  x,z,y = raw.unpack("s>*")
+
+  #calculate angle
+  degrees = (Math::atan2(y, x) * 180) / Math::PI
+  degrees += 360 if degrees < 0
+
+  #read 2 bytes from temperature register
+  raw = i2c.read(0x1e, 2, [0x31].pack("C*"))
+  #temperature is sent big endian, lsd last
+  temp = raw.unpack("S>").first
+  #temp is 12 bits, last 4 are unused
+  temp = temp >> 4
+
+  #twos complement
+  temp -= 65535 if temp > 32767
+
+  #each bit is 8c
+  temp /= 8
+
+  #correction factor
+  temp += 19
+
+  #convert to f
+  temp = (temp * 1.8 + 32).to_i
+
+
+  puts "#{Time.now.strftime("%H:%M")}  temp: #{temp} degrees f        direction: #{degrees.to_i} degrees"
+  sleep 1
+end
+
+exit
+
+
+#procedural method
+
+
+#i2c testing
+I2C.setup(:I2C2)
+
+
+#put mag into continuous conversation mode
+I2C.write(:I2C2, 0x1e, [0x02, 0x00].pack("C*"))
+#enable temperatuer sensor, 15hz register update
+I2C.write(:I2C2, 0x1e, [0x00, "10010000".to_i(2)].pack("C*") )
+#delay for the settings to take effect
+sleep(0.1)
+
+
+loop do
+
+  #read axis data
+  raw = I2C.read(:I2C2, 0x1e, 6, [0x03].pack("C*"))
+
+  #coordinates are signed shorts in x,z,y order
+  x,z,y = raw.unpack("s>*")
+
+  #calculate angle
+  degrees = (Math::atan2(y, x) * 180) / Math::PI
+  degrees += 360 if degrees < 0
+
+  #read 2 bytes from temperature register
+  raw = I2C.read(:I2C2, 0x1e, 2, [0x31].pack("C*"))
+  #temperature is sent big endian, lsd last
+  temp = raw.unpack("S>").first
+  #temp is 12 bits, last 4 are unused
+  temp = temp >> 4
+
+  #twos complement
+  temp -= 65535 if temp > 32767
+
+  #each bit is 8c
+  temp /= 8
+
+  #correction factor
+  temp += 19
+
+  #convert to f
+  temp = (temp * 1.8 + 32).to_i
+
+
+  puts "#{Time.now.strftime("%H:%M")}  temp: #{temp} degrees f        direction: #{degrees.to_i} degrees"
+  sleep 60
+end
+
+exit

data/examples/pwm.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+require 'beaglebone'
+
+include  Beaglebone
+
+#pwm example
+
+#oo method
+p9_14 = PWMPin.new(:P9_14, 90, 10, :NORMAL)
+sleep 1
+p9_14.set_frequency(20)
+sleep(1)
+p9_14.set_duty_cycle(95)
+sleep(1)
+p9_14.set_duty_cycle(50)
+sleep(1)
+p9_14.set_frequency(2)
+sleep(1)
+p9_14.stop
+sleep(1)
+p9_14.run
+sleep(1)
+p9_14.set_frequency(32)
+sleep(1)
+p9_14.set_duty_cycle(94)
+sleep(1)
+p9_14.set_period_ns(31250000)
+p9_14.set_duty_cycle_ns(31250000)
+p9_14.set_period_ns(31249999)
+p9_14.set_duty_cycle(10)
+p9_14.set_polarity(:INVERTED)
+
+p9_14.disable_pwm_pin
+exit
+
+
+#procedural method
+PWM.start(:P9_14, 90, 10, :NORMAL)
+sleep(1)
+PWM.set_frequency(:P9_14, 20)
+sleep(1)
+PWM.set_duty_cycle(:P9_14, 95)
+sleep(1)
+PWM.set_duty_cycle(:P9_14, 50)
+sleep(1)
+PWM.set_frequency(:P9_14, 2)
+sleep(1)
+PWM.stop(:P9_14)
+sleep(1)
+PWM.run(:P9_14)
+sleep(1)
+PWM.set_frequency(:P9_14, 32)
+sleep(1)
+PWM.set_duty_cycle(:P9_14, 94)
+sleep(1)
+PWM.set_period_ns(:P9_14, 31250000)
+PWM.set_duty_cycle_ns(:P9_14, 31250000)
+PWM.set_period_ns(:P9_14, 31249999)
+PWM.set_duty_cycle(:P9_14, 10)
+PWM.set_polarity(:P9_14, :INVERTED)
+sleep(1)
+PWM.cleanup
+exit

data/examples/shiftregister.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require 'beaglebone'
+
+include  Beaglebone
+
+#shift reg via gpio
+
+shiftreg = ShiftRegister.new(:P9_11, :P9_12, :P9_13)
+data = 255
+shiftreg.shiftout(data)
+
+exit

data/examples/spi.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+require 'beaglebone'
+
+include  Beaglebone
+
+#SPI test hooked up to MCP3008
+
+#oo methods
+spi = SPIDevice.new(:SPI0)
+
+loop do
+  # communicate with MCP3008
+  # byte 1: start bit
+  # byte 2: single(1)/diff(0),3 bites for channel, null pad
+  # byte 3: don't care
+  raw = spi.xfer([ 0b00000001, 0b10000000, 0].pack("C*"))
+  data = raw.unpack("C*")
+
+  val = ((data[1] & 0b00000011) << 8 ) | data[2]
+  puts val
+
+
+  raw = spi.xfer([ 0b00000001, 0b10010000, 0].pack("C*"))
+  data = raw.unpack("C*")
+
+  val = ((data[1] & 0b00000011) << 8 ) | data[2]
+  puts val
+
+
+  sleep 0.25
+end
+
+exit
+
+
+#procedural methods
+
+SPI.setup(:SPI0)
+
+loop do
+  # communicate with MCP3008
+  # byte 1: start bit
+  # byte 2: single(1)/diff(0),3 bites for channel, null pad
+  # byte 3: don't care
+  raw = SPI.xfer(:SPI0, [ 0b00000001, 0b10000000, 0].pack("C*"))
+  data = raw.unpack("C*")
+
+  val = ((data[1] & 0b00000011) << 8 ) | data[2]
+  puts val
+
+
+  raw = SPI.xfer(:SPI0, [ 0b00000001, 0b10010000, 0].pack("C*"))
+  data = raw.unpack("C*")
+
+  val = ((data[1] & 0b00000011) << 8 ) | data[2]
+  puts val
+
+
+  sleep 0.25
+end
+
+exit

data/examples/uart.rb

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+require 'beaglebone'
+
+#uart example
+#oo method
+uart5 = UARTDevice.new(:UART5, 9600)
+
+uart5.writeln("TEST")
+
+puts uart5.readchars(10)
+puts uart5.readchar
+puts uart5.readline
+
+callback = lambda { |uart, line, count| puts "[#{uart}:#{count}] #{line} "}
+#uart5.run_on_each_chars(callback, 3, 3)
+#uart5.run_on_each_chars(callback, 3)
+#uart5.run_on_each_char(callback, 3)
+#uart5.run_once_on_each_chars(callback, 3)
+#uart5.run_once_on_each_char(callback)
+#uart5.run_on_each_chars(callback, 2)
+uart5.run_on_each_line(callback)
+
+sleep(5)
+uart5.stop_read_wait
+
+
+uart5.each_chars(2) { |c| puts c }
+#uart5.each_line { |line| puts line }
+
+uart5.disable
+
+exit
+
+
+
+
+#procedural method
+UART.setup(:UART1, 9600)
+
+UART.write(:UART1, "test1")
+
+#puts UART.readchars(:UART1, 10)
+#puts UART.readchar(:UART1)
+#puts UART.readline(:UART1)
+
+callback = lambda { |uart, line, count| puts "[#{uart}:#{count}] #{line} "}
+#UART.run_on_each_chars(callback, :UART1, 3, 3)
+#UART.run_on_each_chars(callback, :UART1, 3)
+#UART.run_on_each_char(callback, :UART1, 3)
+#UART.run_once_on_each_chars(callback, :UART1, 3)
+#UART.run_once_on_each_char(callback, :UART1)
+#UART.run_on_each_chars(callback, :UART1, 2)
+UART.run_on_each_line(callback, :UART1)
+
+sleep(5)
+UART.stop_read_wait(:UART1)
+
+
+UART.each_chars(:UART1, 2) { |c| puts c }
+#UART.each_line(:UART1) { |line| puts line }
+
+UART.cleanup
+
+exit